@nodeswork/nam/dist/server.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Router = require("koa-router");
const Koa = require("Koa");
const url = require("url");
const httpProxy = require("http-proxy");
const http = require("http");
const pathToRegexp = require("path-to-regexp");
const sbase = require("@nodeswork/sbase");
const logger = require("@nodeswork/logger");
const applet = require("@nodeswork/applet");
const utils_1 = require("@nodeswork/utils");
const LOG = logger.getLogger();
class Application extends Koa {
}
exports.Application = Application;
const bodyParser = require('koa-bodyparser');
exports.app = new Application();
const router = new Router();
const version = require('../package.json').version;
const proxy = httpProxy.createProxyServer({});
router
    .get('/sstats', sstats)
    .post('/accounts/:accountId/operate', async (ctx) => {
    const appletId = ctx.request.get(applet.constants.headers.request.APPLET_ID);
    if (appletId == null) {
        throw utils_1.NodesworkError.badRequest('applet id is missing');
    }
    const operateOptions = {
        accountId: ctx.params.accountId,
        appletId,
        body: ctx.request.body,
    };
    try {
        ctx.body = await exports.app.appletManager.operateAccount(operateOptions);
    }
    catch (e) {
        if (e.name === 'StatusCodeError') {
            ctx.status = e.statusCode;
            ctx.body = e.error;
        }
        else {
            throw e;
        }
    }
});
exports.app
    .use(bodyParser())
    .use(router.routes())
    .use(router.allowedMethods());
const routerPathRegex = pathToRegexp('/applets/:appletId/:naType/:naVersion/:packageName/:version/:path*');
const callback = exports.app.callback();
const httpServerCallback = async function (req, res) {
    LOG.info('Receiving request', {
        url: req.url,
        method: req.method,
        headers: req.headers,
    });
    const path = url.parse(req.url);
    const result = routerPathRegex.exec(path.pathname);
    if (result != null) {
        const appletId = result[1];
        const naType = result[2];
        const naVersion = result[3];
        const packageName = result[4];
        const version = result[5];
        const newPath = result[6] || '';
        const route = await exports.app.appletManager.route({
            appletId, naType, naVersion, packageName, version,
        });
        if (newPath === 'sstruct') {
            const origin = req.headers.origin;
            if (origin != null) {
                res.setHeader('Access-Control-Allow-Origin', origin);
                res.setHeader('Access-Control-Allow-Credentials', 'true');
            }
        }
        if (route != null) {
            req.url = newPath;
            req.headers[sbase.constants.headers.request.NODESWORK_FORWARDED_TO] = (route.route);
            proxy.web(req, res, {
                target: route.target,
                xfwd: true,
                toProxy: true,
            }, (e) => {
                res.writeHead(500, { 'Content-Type': 'text/plain' });
                const message = 'Routing Error in nam.';
                res.end(message);
                console.error(message, e);
            });
            return;
        }
        else {
            LOG.warn('Route not found', { path: result[0] });
        }
    }
    callback(req, res);
};
exports.server = http.createServer(httpServerCallback);
async function sstats(ctx) {
    ctx.body = {
        app: {
            name: 'nam',
            version,
        },
        applets: {
            status: await exports.app.appletManager.ps(),
        },
    };
}

//# sourceMappingURL=server.js.map