bf-lib/system/System.js

"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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const Utils_1 = require("../system/Utils");
const EventBus_1 = __importDefault(require("./EventBus"));
const Instrumentor_1 = require("./Instrumentor");
const Nexus_1 = __importDefault(require("./Nexus"));
const Types_1 = require("./Types");
let initialized = false;
let protectedMode = false;
const seal = Symbol();
function lock(obj, key) {
    const guard = Object.freeze({ key });
    function unlock(suppliedKey) {
        const keyRef = suppliedKey;
        if (typeof keyRef === 'symbol' && guard.key === keyRef) {
            return obj;
        }
        throw new Error('illegal access to a protected object');
    }
    Object.defineProperty(unlock, 'name', { value: Symbol() });
    Object.defineProperty(unlock, 'prototype', { value: null });
    Object.defineProperty(unlock, '__proto__', { value: null });
    return Object.freeze(unlock);
}
function sealModule(module) {
    return lock(module, seal);
}
function init(settings) {
    return __awaiter(this, void 0, void 0, function* () {
        if (initialized && protectedMode) {
            return;
        }
        const { logger, mask } = settings.logging;
        const debugLoggingEnabled = !mask.includes('debug');
        function log(level, message) {
            switch (level) {
                case 'debug': {
                    if (debugLoggingEnabled) {
                        logger[level](message);
                    }
                    break;
                }
                default: {
                    logger[level](message);
                    break;
                }
            }
        }
        log('debug', 'beginning to initialize the internal bf-lib system');
        Instrumentor_1.SetInstrumentorLogger(log);
        const httpHeaders = {};
        const impersonateHeaders = settings.impersonate || {};
        const libModuleMap = new Map();
        const nexus = yield Nexus_1.default(system, settings.nexus, settings.auth);
        const eventBus = EventBus_1.default();
        protectedMode = settings.protected || false;
        function getEventBus() {
            return eventBus;
        }
        function getHttpHeaders() {
            return Object.assign({}, httpHeaders);
        }
        function getImpersonationHeaders() {
            return Object.assign({}, impersonateHeaders);
        }
        function isProtected() {
            return protectedMode;
        }
        function setHttpHeader(key, value) {
            httpHeaders[key] = value;
        }
        function getLibModule(type) {
            const libModule = libModuleMap.get(type);
            if (!libModule) {
                throw new Error('An attempt was mad to access an instance for a missing Lib Module.');
            }
            return libModule(seal);
        }
        log('debug', 'beginning to initialize all system lib modules');
        libModuleMap.set(Types_1.LibModule.AUTH, require('../auth/Auth').default);
        libModuleMap.set(Types_1.LibModule.API, require('../api/Api').default);
        libModuleMap.set(Types_1.LibModule.MODULE, require('../module/Module').default);
        libModuleMap.set(Types_1.LibModule.MULTITOOL, require('../multitool/Multitool').default);
        log('debug', 'finished initializing all system lib modules');
        const instanceMethods = {
            isProtected,
            getEventBus,
            getHttpHeaders,
            getImpersonationHeaders,
            setHttpHeader,
            getLibModule,
            nexus,
        };
        Object.assign(instance, instanceMethods);
        if (settings.auth.afterConnect) {
            settings.auth.afterConnect(instance);
        }
        initialized = true;
        log('debug', 'finished initializing the internal bf-lib system');
    });
}
const [instance, system] = Utils_1.proxyWrap({}, { init, sealModule });
exports.default = system;