@micro.ts/core/brokers/http/hapi/HapiBroker.js

Microservice framework with Typescript

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HapiBroker = void 0;
// import { Server as HapiServer, Request as HapiRequest, ResponseToolkit, ServerOptions as HapiServerOptions } from 'hapi';
const hapi_1 = require("@hapi/hapi");
const HttpBroker_1 = require("../HttpBroker");
const Logger_1 = require("../../../server/Logger");
const di_1 = require("../../../di");
class HapiBroker extends HttpBroker_1.HttpBroker {
    constructor() {
        super(...arguments);
        this.name = 'HapiBroker';
        this.requestMapper = (r) => __awaiter(this, void 0, void 0, function* () {
            const act = {
                request: {
                    params: r.params,
                    path: r.path,
                    headers: r.headers,
                    method: r.method,
                    body: r.payload,
                    qs: r.query,
                    raw: r
                },
                connection: r.server
            };
            return act;
        });
    }
    get logger() {
        return di_1.Container.get(Logger_1.LoggerKey);
    }
    construct() {
        this.server = new hapi_1.Server(this.config);
    }
    respond(result, h) {
        const body = result.response.body || result.response.error;
        let response = h.response(body).code(result.response.statusCode || 200);
        const headers = result.response.headers || {};
        Object.keys(headers).forEach(h => {
            response = response.header(h, headers[h]);
        });
        return response;
    }
    registerHandler(value, route, method) {
        const filteredDef = value.find(x => x.def.method === method);
        let options = {};
        if (filteredDef && filteredDef.def.brokerRouteOptions) {
            options = filteredDef.def.brokerRouteOptions(this);
        }
        this.server.route({
            method: method,
            path: route,
            options,
            handler: (r, h) => __awaiter(this, void 0, void 0, function* () {
                const action = yield this.requestMapper(r);
                const handler = this.actionToRouteMapper(route, action, value);
                const result = yield handler(action);
                result.response = result.response || {};
                return this.respond(result, h);
            })
        });
    }
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            this.registerRoutes();
            yield this.server.start();
            this.server.listener.on('close', (e) => this.handleConnectionError(e));
            this.server.listener.on('error', (e) => this.handleConnectionError(e));
            this.logger.info(`Server listening on address ${this.config.address} and port ${this.config.port}`);
        });
    }
    paramWrapper(paramName) {
        return `{${paramName}}`;
    }
}
exports.HapiBroker = HapiBroker;