jai-server/dist/lib/next.js

Fast , simple and powerful web framework for creating REST APIs for your next project. RESTFul API server

"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 });
const path = __importStar(require("path"));
const matcher_1 = __importDefault(require("./matcher"));
const routeObjectMaker_1 = __importDefault(require("./routeObjectMaker"));
const errorHandler_1 = require("./request/errorHandler");
function isHandlerFunction(handler) {
    return typeof handler === 'function';
}
function isHandlerObject(handler) {
    return typeof handler === 'object' && Array.isArray(handler.stack);
}
const Error404 = JSON.stringify({ statusCode: 404, error: 'Not Found', message: 'Not Found' });
function Next(req, res, i, mwLength, stack, contUrl = '/') {
    return async function NextHandler(nextError) {
        try {
            while (i < mwLength) {
                const middleware = stack[i];
                if (!middleware) {
                    i++;
                    continue;
                }
                const { url, isUse, method, handler, isErrorHandler } = middleware;
                let urlMatched = !url;
                let params = {};
                let nextUrl = contUrl;
                if (url) {
                    const urls = Array.isArray(url) ? url : [url];
                    for (const u of urls) {
                        if (u == null) {
                            urlMatched = true;
                            break;
                        }
                        nextUrl = path.join(contUrl, u);
                        params = (0, matcher_1.default)(nextUrl, req.url.split('?')[0], !isUse && isHandlerFunction(handler));
                        if (params) {
                            urlMatched = true;
                            break;
                        }
                    }
                }
                const methodMatched = !method || req.method === method;
                if (!urlMatched || !methodMatched) {
                    i++;
                    continue;
                }
                if (isHandlerFunction(handler)) {
                    req.params = params;
                    const nextFunction = Next(req, res, i + 1, mwLength, stack, contUrl);
                    if (!nextError && isErrorHandler) {
                        return await nextFunction(nextError);
                    }
                    try {
                        if (nextError && !isErrorHandler)
                            return await nextFunction(nextError);
                        const args = nextError && isErrorHandler
                            ? [nextError, req, res, nextFunction]
                            : [req, res, nextFunction];
                        return await handler(...args);
                    }
                    catch (error) {
                        return await nextFunction(error);
                    }
                }
                else if (isHandlerObject(handler)) {
                    const newStack = handler.stack.concat([(0, routeObjectMaker_1.default)({
                            callback: async (err, req, res) => await Next(req, res, i + 1, mwLength, stack, contUrl)(err || nextError),
                            url: null, method: null, isUse: true, isErrorHandler: true
                        }),
                        (0, routeObjectMaker_1.default)({
                            callback: async (req, res) => await Next(req, res, i + 1, mwLength, stack, contUrl)(nextError),
                            url: null, method: null, isUse: true, isErrorHandler: false
                        })
                    ]);
                    return await Next(req, res, 0, newStack.length, newStack, isUse ? nextUrl : contUrl)(nextError);
                }
                i++;
            }
            if (nextError)
                throw nextError;
            if (!res.headersSent) {
                res.writeHead(404, { 'Content-Type': 'application/json' });
                res.end(Error404);
            }
        }
        catch (error) {
            (0, errorHandler_1.ErrorHandler500)(res, error);
        }
    };
}
exports.default = Next;