@fusion.io/authenticate/lib/Authenticator.js

"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;
};
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("@fusion.io/core");
/**
 * An authenticator service. It its simplest form, it managing
 * gateways
 *
 */
let Authenticator = class Authenticator extends core_1.Manager {
    /**
     * An authenticator service. It its simplest form, it managing
     * gateways
     *
     */
    constructor() {
        super(...arguments);
        this.gatewayConnectors = new Map();
    }
    /**
     * Connect an IDP to the gateway
     *
     * @param gateway
     * @param connector
     */
    connect(gateway, connector) {
        this.gatewayConnectors.set(gateway, connector);
        return this;
    }
    /**
     *
     * @param config
     */
    bootstrap(config) {
        const standardAdapterConfiguration = Object.entries(config.gateways)
            .reduce((merged, [gatewayName, { protocol, options }]) => (Object.assign({}, merged, { [gatewayName]: {
                driver: protocol,
                options: Object.assign({}, options, { 
                    // We'll allow the consumer code connects
                    // its IDP to the gateway
                    connector: this.gatewayConnectors.get(gatewayName) })
            } })), {});
        return this.configure({
            default: config.default,
            adapters: standardAdapterConfiguration
        });
    }
    /**
     * Overrides the install adapter method to connect the gateway with IDP
     *
     * @param configuration
     */
    installAdapter(configuration) {
        const gateway = super.installAdapter(configuration);
        if (configuration.options.connector) {
            let providers = configuration.options.connector(configuration.options);
            if (!(providers instanceof Array))
                providers = [providers];
            providers.forEach(provider => gateway.provider.push(provider));
        }
        return gateway;
    }
    /**
     * Authenticate a context by a given gateway
     *
     * @param gateway
     * @param context
     */
    authenticate(gateway, context) {
        return this.adapter(gateway).authenticate(context);
    }
    /**
     * Returning a connection which can be used to mount to
     * the transport layer
     *
     * Normally, we need to authenticate over Http, then guard() will
     * return a middleware
     *
     * If we authenticate over Socket, then guard() will return the
     * socket connection middleware
     *
     * @param gateway
     * @return {mount}
     */
    guard(gateway) {
        // First we'll wrap exposed function. By doing this way, the logic for checking
        // the Gateway existence will be done in the mounted context.
        // Not the initial setup context.
        return (...arg) => {
            // Now we are actually inside the context.
            // we check for the protocol of the gateway
            const protocol = this.adapter(gateway).protocol;
            if ('function' !== typeof protocol.mount) {
                throw new Error(`The protocol [${protocol.constructor.name}] of the gateway [${gateway}]` +
                    ` does not support mounting to a framework.`);
            }
            // Create a consumer function which actually run the authentication process
            const consumer = (context) => this.authenticate(gateway, context);
            // Get give the consumer to the protocol
            // and get back the mount function.
            const mountFunction = protocol.mount(consumer);
            // Lastly, we'll trigger the mountFunction here here
            return mountFunction(...arg);
        };
    }
};
Authenticator = __decorate([
    core_1.singleton()
], Authenticator);
exports.Authenticator = Authenticator;
//# sourceMappingURL=Authenticator.js.map