@akala/server/dist/worker-meta.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const router_1 = require("./router");
exports.Router = router_1.WorkerRouter;
const akala = require("@akala/core");
const stream = require("stream");
const send = require("send");
const onFinished = require("on-finished");
const log = akala.log('akala:worker');
function createClient(namespace) {
    return akala.resolve('$agent.' + namespace);
}
exports.createClient = createClient;
const masterPrefixes = ['header', 'route', 'query', 'body'];
class WorkerInjectorImpl extends akala.Injector {
    constructor(request) {
        super();
        this.request = request;
    }
    resolve(name) {
        let indexOfDot = name.indexOf('.');
        if (~indexOfDot) {
            let master = name.substr(0, indexOfDot);
            if (~masterPrefixes.indexOf(master)) {
                log(`resolving ${name}`);
                switch (master) {
                    case 'header':
                        return this.request.headers[name.substr(indexOfDot + 1)];
                    case 'query':
                        return this.request.query && this.request.query[name.substr(indexOfDot + 1)];
                    case 'route':
                        log(this.request.params);
                        return this.request.params && this.request.params[name.substr(indexOfDot + 1)];
                    case 'body':
                        return this.request.body && this.request.body[name.substr(indexOfDot + 1)];
                }
            }
        }
        return super.resolve(name);
    }
}
exports.WorkerInjectorImpl = WorkerInjectorImpl;
function expressWrap(handler) {
    return function (req, next) {
        var callback = req.injector.resolve('$callback');
        var headers = {};
        var response = buildResponse(req, callback, next);
        handler(req, response, next);
    };
}
exports.expressWrap = expressWrap;
function buildResponse(req, callback, next) {
    return new MyResponse(req, callback, next);
}
class MyResponse extends stream.Transform {
    constructor(req, callback, next) {
        super({
            transform: (chunk, _encoding, callback) => {
                callback(null, chunk);
            }, decodeStrings: true
        });
        this.req = req;
        this.isStream = false;
        this.headers = {};
        this.links = undefined;
        this.jsonp = undefined;
        this.sendfile = undefined;
        this.download = undefined;
        this.type = undefined;
        this.format = undefined;
        this.attachment = undefined;
        this.headersSent = false;
        this.get = undefined;
        this.clearCookie = undefined;
        this.cookie = undefined;
        /**
            * Render `view` with the given `options` and optional callback `fn`.
            * When a callback function is given a response will _not_ be made
            * automatically, otherwise a response of _200_ and _text/html_ is given.
            *
            * Options:
            *
            *  - `cache`     boolean hinting to the engine it should cache
            *  - `filename`  filename of the view being rendered
            */
        this.render = undefined;
        /**
         * Adds the field to the Vary response header, if it is not there already.
         * Examples:
         *
         *     res.vary('User-Agent').render('docs');
         *
         */
        this.vary = undefined;
        this.app = undefined;
        this.setTimeout = undefined;
        this.addTrailers = undefined;
        this.writeContinue = undefined;
        this.finished = false;
        this.writable = true;
        this.headers = {};
        this.sendStatus = callback;
        this.status = callback;
        this.send = callback;
        this.json = callback;
        this.on('pipe', () => {
            this.isStream = true;
        });
        this.on('end', () => { this.send(this); });
    }
    sendFile(path, options, callback) {
        var encodedPath = encodeURI(path);
        var done = callback;
        var req = this.req;
        var res = this;
        var next = function (err) {
            if (err)
                res.send(500, err);
            else
                res.send(200);
        };
        var opts = options || {};
        if (!path) {
            throw new TypeError('path argument is required to res.sendFile');
        }
        // support function as second arg
        if (typeof options === 'function') {
            done = options;
            opts = {};
        }
        // create file stream
        var pathname = encodeURI(path);
        var file = send(req, pathname, opts);
        // transfer
        sendfile(res, file, opts, function (err) {
            if (done)
                return done(err);
            if (err && err.code === 'EISDIR')
                return next();
            // next() all but write errors
            if (err && err.code !== 'ECONNABORTED' && err.syscall !== 'write') {
                next(err);
            }
        });
    }
    contentType(type) { this.setHeader('contentType', type); return this; }
    set(field, value) {
        return this.header(field, value);
    }
    header(field, value) {
        if (typeof field == 'string') {
            if (typeof (value) == 'undefined')
                return this.headers[field];
            this.setHeader(field, value);
            return this;
        }
        else {
            var self = this;
            if (field)
                akala.each(field, function (value, key) {
                    self.setHeader(key, value);
                });
        }
    }
    location(location) { this.setHeader('location', location); return this; }
    setHeader(field, value) {
        this.headers[field] = value;
    }
    redirect(url, status) {
        if (typeof (status) == 'undefined')
            status = 302;
        if (typeof (url) == 'number' && typeof (status) == 'string') {
            var swap = url;
            url = status;
            status = swap;
        }
        this.setHeader('location', url);
        this.send(status);
    }
    writeHead(statusCode, reasonPhrase, headers) {
        log('writeHead');
        this.statusCode = statusCode;
        if (typeof reasonPhrase != 'string') {
            headers = reasonPhrase;
            reasonPhrase = null;
        }
        if (reasonPhrase)
            this.statusMessage = reasonPhrase;
        this.header(headers);
        this.send(this);
        this.headersSent = true;
    }
    getHeader(name) {
        return this.headers[name];
    }
    ;
    removeHeader(name) {
        delete this.headers[name];
    }
    _write(chunk, encoding, callback) {
        if (!this.headersSent)
            this.writeHead(this.statusCode);
        super['_write'](chunk, encoding, callback);
    }
}
function handle(app, root) {
    return function handle(request, next) {
        return new Promise((resolve, reject) => {
            var callback = function callback(status, data) {
                var response;
                if (arguments.length == 0)
                    return reject();
                if (arguments.length == 1 && status === 'route')
                    return reject(status);
                if (isNaN(Number(status)) || Array.isArray(status)) {
                    response = status;
                    if (typeof (data) == 'undefined') {
                        if (typeof (status) == 'undefined')
                            response = { statusCode: 404, data: 'Not found' };
                        else if (isNaN(Number(response.statusCode)) && !(response instanceof stream.Readable)) {
                            data = response;
                            response = { statusCode: 200, data: data };
                            status = null;
                        }
                        else
                            data = undefined;
                        status = null;
                    }
                }
                else
                    response = { statusCode: status, data: 'No data' };
                response.statusCode = response.statusCode || 200;
                if (!(data instanceof stream.Readable) && !Buffer.isBuffer(data) && typeof (data) !== 'string' && typeof data != 'number' && typeof (data) != 'undefined') {
                    if (!response.headers)
                        response.headers = {};
                    if (data instanceof Error) {
                        if (!response.headers['Content-Type'])
                            response.headers['Content-Type'] = 'text/text';
                        data = data.stack;
                    }
                    else {
                        if (!response.headers['Content-Type'])
                            response.headers['Content-Type'] = 'application/json';
                        data = JSON.stringify(data);
                    }
                }
                if (typeof (data) != 'undefined')
                    response.data = data;
                resolve(response);
            };
            callback.redirect = function (url) {
                return callback({ status: 302, headers: { location: url } });
            };
            var requestInjector = new WorkerInjectorImpl(request);
            requestInjector.register('$request', request);
            requestInjector.register('$callback', callback);
            // log(request);
            Object.defineProperty(request, 'injector', { value: requestInjector, enumerable: false, configurable: false, writable: false });
            log(request.url);
            app.handle(request, callback, function (err, _req, _callback) {
                reject(err);
            });
        });
    };
}
exports.handle = handle;
function sendfile(res, file, options, callback) {
    var done = false;
    var streaming;
    // request aborted
    function onaborted() {
        if (done)
            return;
        done = true;
        var err = new Error('Request aborted');
        err['code'] = 'ECONNABORTED';
        callback(err);
    }
    // directory
    function ondirectory() {
        if (done)
            return;
        done = true;
        var err = new Error('EISDIR, read');
        err['code'] = 'EISDIR';
        callback(err);
    }
    // errors
    function onerror(err) {
        if (done)
            return;
        done = true;
        callback(err);
    }
    // ended
    function onend() {
        if (done)
            return;
        done = true;
        callback();
    }
    // file
    function onfile() {
        streaming = false;
    }
    // finished
    function onfinish(err) {
        if (err && err.code === 'ECONNRESET')
            return onaborted();
        if (err)
            return onerror(err);
        if (done)
            return;
        setImmediate(function () {
            if (streaming !== false && !done) {
                onaborted();
                return;
            }
            if (done)
                return;
            done = true;
            callback();
        });
    }
    // streaming
    function onstream() {
        streaming = true;
    }
    file.on('directory', ondirectory);
    file.on('end', onend);
    file.on('error', onerror);
    file.on('file', onfile);
    file.on('stream', onstream);
    onFinished(res, onfinish);
    if (options.headers) {
        // set headers on successful transfer
        file.on('headers', function headers(res) {
            var obj = options.headers;
            var keys = Object.keys(obj);
            for (var i = 0; i < keys.length; i++) {
                var k = keys[i];
                res.setHeader(k, obj[k]);
            }
        });
    }
    // pipe
    file.pipe(res);
}
//# sourceMappingURL=worker-meta.js.map