conveyor-koa-connector/lib/index.js

Koa Webhook connector for conveyor-client

'use strict';

let connect = (() => {
    var _ref = _asyncToGenerator(function* (koaApp, connectionOrClient, baseUrl) {
        const callbackEndpoint = `/${crypto.randomBytes(16).toString('hex')}`;

        const buffer = new EventBuffer();
        koaApp.use((() => {
            var _ref2 = _asyncToGenerator(function* (ctx, next) {
                if (ctx.path !== callbackEndpoint) {
                    yield next();
                    return;
                }

                if (ctx.method === 'GET') {
                    const challenge = ctx.query.challenge;

                    ctx.body = challenge;
                    return;
                } else if (ctx.method === 'POST' && typeof ctx.request.body === 'object') {
                    buffer.emit(ctx.request.body);
                    ctx.status = 200;
                }
            });

            function withConveyorSubscriptionWebhook(_x4, _x5) {
                return _ref2.apply(this, arguments);
            }

            return withConveyorSubscriptionWebhook;
        })());

        let connection;
        if (connectionOrClient.getConnection) {
            connection = connectionOrClient.getConnection();
        } else {
            connection = connectionOrClient;
        }

        let doCancel;
        // Defer registration until the koa app is up and ready to respond to the webhook
        const oldCallback = koaApp.callback.bind(koaApp);
        koaApp.callback = function conveyorWrappedCallback() {
            impl.registerSubscriptionImpl(connection, function registerImplementation(emit, cancel) {
                buffer.setEmitImpl(emit);
                doCancel = cancel;
                return baseUrl + callbackEndpoint;
            }).catch(err => console.error('Error subscribing to Conveyor events', err));

            return oldCallback();
        };

        return (() => {
            var _ref3 = _asyncToGenerator(function* () {
                if (doCancel) {
                    yield doCancel();
                }
            });

            function cancel() {
                return _ref3.apply(this, arguments);
            }

            return cancel;
        })();
    });

    return function connect(_x, _x2, _x3) {
        return _ref.apply(this, arguments);
    };
})();

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

var _require = require('conveyor-client');

const impl = _require.impl;

const crypto = require('crypto');

class EventBuffer {

    constructor() {
        this.events = [];
        this.emitImpl = null;
    }

    emit(event) {
        if (this.emitImpl) {
            this.emitImpl(event);
        } else {
            this.events.push(event);
        }
    }

    setEmitImpl(emitImpl) {
        this.emitImpl = emitImpl;
        if (this.events.length > 0) {
            this.events.forEach(e => this.emitImpl(e));
            this.events = [];
        }
    }
}

module.exports = connect;