@dazejs/framework/dist/http/server/server.js

Daze.js - A powerful web framework for Node.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AppServer = void 0;
const http = __importStar(require("http"));
const https = __importStar(require("https"));
const container_1 = require("../../container");
const handle_1 = require("../../errors/handle");
const http_error_1 = require("../../errors/http-error");
const request_1 = require("../request");
const manager_1 = require("../response/manager");
const debug_1 = __importDefault(require("debug"));
const middleware_1 = require("../middleware");
const symbol_1 = require("../../symbol");
const helpers_1 = require("../../helpers");
const debug = (0, debug_1.default)('@dazejs/framework:server');
class AppServer {
    constructor() {
        this.app = container_1.Container.get('app');
    }
    getServer() {
        return this.server;
    }
    createServer() {
        const middleware = this.app.get(middleware_1.MiddlewareService);
        const callback = async (req, res) => {
            debug('接收请求');
            const router = this.app.get('router');
            const request = new request_1.Request(req, res);
            const matchedRoute = router.match(request);
            await request.initialize(matchedRoute);
            debug('已初始化 Request 对象');
            const conextStore = new Map();
            (0, helpers_1.app)().get(symbol_1.ASYNC_LOCAL_STORAGE).run(conextStore, async () => {
                conextStore.set('request', request);
                try {
                    const resolver = router.createResolver(matchedRoute);
                    const response = await middleware.handle(request, resolver);
                    const code = response.getCode();
                    const data = response.getData();
                    const headers = response.getHeaders();
                    if (code >= 400 && !response.isForce()) {
                        throw new http_error_1.HttpError(code, data, headers);
                    }
                    await this.end(response, request);
                }
                catch (err) {
                    const handler = new handle_1.ErrorHandler(err, request);
                    handler.report();
                    if (err.report && typeof err.report === 'function')
                        err.report();
                    if (err.render && typeof err.render === 'function') {
                        return new manager_1.ResponseManager(err.render(this.app)).output(request);
                    }
                    else {
                        const handler = new handle_1.ErrorHandler(err, request);
                        return new manager_1.ResponseManager(handler.render()).output(request);
                    }
                }
            });
        };
        if (this.app.isHttps) {
            this.server = https.createServer(this.app.httpsOptions, callback);
        }
        else {
            this.server = http.createServer(callback);
        }
        this.server.on('clientError', (_, socket) => {
            if (!socket.writable) {
                return;
            }
            return socket.end('400 Bad Request\r\n\r\n');
        });
        return this.server;
    }
    async end(data, request) {
        try {
            await new manager_1.ResponseManager(data).output(request);
        }
        catch (err) {
            this.app.emit('error', err);
        }
    }
    listen(...args) {
        return this.server.listen(...args);
    }
}
exports.AppServer = AppServer;
//# sourceMappingURL=server.js.map