@d3vtool/kazejs
Version:
A flexible Node.js web framework built with TypeScript, focusing on dependency injection, routing, middleware, and schema validation. Supports dynamic routes, global middleware, static files, and customizable error handling for scalable apps.
480 lines (479 loc) • 26.3 kB
JavaScript
"use strict";
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _Kaze_instances, _Kaze_router, _Kaze_isHttps, _Kaze_port, _Kaze_server, _Kaze_contentLength, _Kaze_mimeType, _Kaze_respStatusCode, _Kaze_responseData, _Kaze_responseSent, _Kaze_errorHandler, _Kaze_validationFailedHandler, _Kaze_staticDirPath, _Kaze_isClassBased, _Kaze_errorMap, _Kaze_vErrorMap, _Kaze_renderingEngineInfo, _Kaze_globalMiddlewares, _Kaze_defaultErrorHandler, _Kaze_defaultVFailedHandler, _Kaze_getStaticMethods, _Kaze_getPossibleMatchingRoutes, _Kaze_anyErrorHandler, _Kaze_vErrorHandler, _Kaze_appendToMapRouter, _Kaze_checkFileExists, _Kaze_readFile, _Kaze_sendFile, _Kaze_send, _Kaze_html, _Kaze_json, _Kaze_render, _Kaze_statusCode, _Kaze_handleResponse, _Kaze_handleStaticFile, _Kaze_handle, _Kaze_resetServerState;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Kaze = exports.AcceptedMethods = void 0;
const node_http_1 = __importDefault(require("node:http"));
const node_path_1 = __importDefault(require("node:path"));
const promises_1 = __importDefault(require("node:fs/promises"));
const utils_1 = require("@d3vtool/utils");
const kaze_map_router_1 = require("./kaze-map-router");
const kaze_utils_1 = require("./kaze-utils");
const kaze_errors_1 = require("./kaze-errors");
const kaze_cookies_1 = require("./kaze-cookies");
const kaze_fileupload_1 = require("./kaze-fileupload");
const kaze_body_1 = require("./kaze-body");
exports.AcceptedMethods = new Set([
"GET",
"POST",
"PUT",
"PATCH",
"DELETE",
"HEAD",
"TRACE",
"OPTIONS",
"CONNECT",
"LINK",
"UNLINK",
]);
class Kaze {
constructor(options) {
_Kaze_instances.add(this);
_Kaze_router.set(this, void 0);
_Kaze_isHttps.set(this, void 0);
_Kaze_port.set(this, 8657);
_Kaze_server.set(this, void 0);
_Kaze_contentLength.set(this, 0);
_Kaze_mimeType.set(this, "text/plain");
_Kaze_respStatusCode.set(this, 200);
_Kaze_responseData.set(this, "");
_Kaze_responseSent.set(this, false);
_Kaze_errorHandler.set(this, void 0);
_Kaze_validationFailedHandler.set(this, void 0);
_Kaze_staticDirPath.set(this, "");
_Kaze_isClassBased.set(this, false);
_Kaze_errorMap.set(this, {});
_Kaze_vErrorMap.set(this, {});
_Kaze_renderingEngineInfo.set(this, void 0);
_Kaze_globalMiddlewares.set(this, new Set());
if (options?.class) {
__classPrivateFieldSet(this, _Kaze_isClassBased, true, "f");
Kaze.routerClass = kaze_map_router_1.MapRouter;
}
else {
Kaze.routerClass = options?.router ?? kaze_map_router_1.MapRouter;
}
if (typeof Kaze.routerClass !== 'function') {
throw new Error('Invalid router class');
}
__classPrivateFieldSet(this, _Kaze_router, new Kaze.routerClass(), "f");
__classPrivateFieldSet(this, _Kaze_isHttps, false, "f");
__classPrivateFieldSet(this, _Kaze_errorHandler, __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_defaultErrorHandler), "f");
__classPrivateFieldSet(this, _Kaze_validationFailedHandler, __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_defaultVFailedHandler), "f");
__classPrivateFieldSet(this, _Kaze_renderingEngineInfo, {
renderEngineDirPath: "",
renderEngine: (rctx, template, _) => template,
}, "f");
__classPrivateFieldSet(this, _Kaze_server, node_http_1.default.createServer((req, res) => {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handle).call(this, req, res, options?.dependencies);
}), "f");
}
static Router(router = kaze_map_router_1.MapRouter) {
return new router();
}
static parseCookie() {
return kaze_cookies_1.parseCookies;
}
static parseBody() {
return (0, kaze_body_1.parseBody)();
}
static fileUpload(options) {
return (0, kaze_fileupload_1.fileUpload)(options);
}
static(directoryPath) {
__classPrivateFieldSet(this, _Kaze_staticDirPath, directoryPath, "f");
}
renderEngine(engine, directoryPath, options) {
__classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderEngine = engine;
__classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderingEngineOptions = options;
__classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderEngineDirPath = directoryPath;
}
addGlobalMiddleware(middleware) {
if (Array.isArray(middleware)) {
middleware.forEach(mdWare => {
__classPrivateFieldGet(this, _Kaze_globalMiddlewares, "f").add(mdWare);
});
}
else {
__classPrivateFieldGet(this, _Kaze_globalMiddlewares, "f").add(middleware);
}
}
globalErrorHandler(fn) {
__classPrivateFieldSet(this, _Kaze_errorHandler, fn, "f");
}
globalVErrorHandler(fn) {
__classPrivateFieldSet(this, _Kaze_validationFailedHandler, fn, "f");
}
get(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").get(route, ...reqHandler);
}
post(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").post(route, ...reqHandler);
}
put(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").put(route, ...reqHandler);
}
delete(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").delete(route, ...reqHandler);
}
patch(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").patch(route, ...reqHandler);
}
head(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").head(route, ...reqHandler);
}
options(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").options(route, ...reqHandler);
}
trace(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").trace(route, ...reqHandler);
}
connect(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").connect(route, ...reqHandler);
}
link(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").link(route, ...reqHandler);
}
unlink(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").unlink(route, ...reqHandler);
}
all(route, ...reqHandler) {
__classPrivateFieldGet(this, _Kaze_router, "f").all(route, ...reqHandler);
}
routeGrp(parentRoute, router) {
if (router instanceof kaze_map_router_1.MapRouter) {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_appendToMapRouter).call(this, parentRoute, router);
}
}
controller(controller) {
if (!__classPrivateFieldGet(this, _Kaze_isClassBased, "f"))
return;
const parentRoute = controller.parentRoute ?? "/";
const parentMiddlewares = controller["handlers"] ?? [];
const parentErrorHandler = controller?.errorHandler;
const parentVErrorHandler = controller?.vErrorHandler;
if (parentErrorHandler) {
__classPrivateFieldGet(this, _Kaze_errorMap, "f")[parentRoute] = parentErrorHandler;
}
if (parentVErrorHandler) {
__classPrivateFieldGet(this, _Kaze_vErrorMap, "f")[parentRoute] = parentVErrorHandler;
}
const router = Kaze.Router();
router.middlewares(...parentMiddlewares);
for (const methodName of __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_getStaticMethods).call(this, controller)) {
const controllerMethod = controller[methodName];
const httpMethod = controllerMethod?.httpMethod;
const controllerRoute = controllerMethod?.route;
const controllerMiddlewares = controllerMethod?.handlers ?? [];
const errorHandler = controllerMethod?.errorHandler;
const vErrorHandler = controllerMethod?.vErrorHandler;
const fullRoute = `${parentRoute}${controllerRoute === "/" ? "" : controllerRoute}`.trim();
if (errorHandler) {
__classPrivateFieldGet(this, _Kaze_errorMap, "f")[fullRoute] = errorHandler;
}
if (vErrorHandler) {
__classPrivateFieldGet(this, _Kaze_vErrorMap, "f")[fullRoute] = vErrorHandler;
}
if (!httpMethod ||
!controllerMethod ||
!controllerMiddlewares)
continue;
router[httpMethod](controllerRoute, ...controllerMiddlewares, controllerMethod);
}
this.routeGrp(parentRoute, router);
}
getHandle(isHttps) {
__classPrivateFieldSet(this, _Kaze_isHttps, isHttps, "f");
return __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handle).bind(this);
}
port() {
return __classPrivateFieldGet(this, _Kaze_port, "f");
}
close() {
__classPrivateFieldGet(this, _Kaze_server, "f").close();
}
listen(port, listeningListener) {
if (__classPrivateFieldGet(this, _Kaze_isClassBased, "f")) {
this.globalErrorHandler(__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_anyErrorHandler));
this.globalVErrorHandler(__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_vErrorHandler));
}
__classPrivateFieldSet(this, _Kaze_port, port, "f");
__classPrivateFieldGet(this, _Kaze_server, "f").listen(__classPrivateFieldGet(this, _Kaze_port, "f"), listeningListener);
}
}
exports.Kaze = Kaze;
_Kaze_router = new WeakMap(), _Kaze_isHttps = new WeakMap(), _Kaze_port = new WeakMap(), _Kaze_server = new WeakMap(), _Kaze_contentLength = new WeakMap(), _Kaze_mimeType = new WeakMap(), _Kaze_respStatusCode = new WeakMap(), _Kaze_responseData = new WeakMap(), _Kaze_responseSent = new WeakMap(), _Kaze_errorHandler = new WeakMap(), _Kaze_validationFailedHandler = new WeakMap(), _Kaze_staticDirPath = new WeakMap(), _Kaze_isClassBased = new WeakMap(), _Kaze_errorMap = new WeakMap(), _Kaze_vErrorMap = new WeakMap(), _Kaze_renderingEngineInfo = new WeakMap(), _Kaze_globalMiddlewares = new WeakMap(), _Kaze_instances = new WeakSet(), _Kaze_defaultErrorHandler = function _Kaze_defaultErrorHandler(ctx, error) {
ctx.res.statusCode(500);
if (error instanceof Error) {
ctx.res.html((0, kaze_utils_1.transformErrorStackToHtml)(error.stack ?? error.message));
}
}, _Kaze_defaultVFailedHandler = function _Kaze_defaultVFailedHandler(ctx, error) {
const errors = error.vErrors;
ctx.res.send(JSON.stringify(errors));
}, _Kaze_getStaticMethods = function _Kaze_getStaticMethods(cls) {
return Object.getOwnPropertyNames(cls)
.filter((item) => typeof cls[item] === "function");
}, _Kaze_getPossibleMatchingRoutes = function _Kaze_getPossibleMatchingRoutes(route, map) {
const routeSeg = route.split("/");
const viableERoutes = [];
for (const errorRoute in map) {
const eRouteSeg = errorRoute.split("/");
if (errorRoute.includes("/:") && eRouteSeg.length === routeSeg.length) {
viableERoutes.unshift(errorRoute);
}
else if (route.includes(errorRoute)) {
viableERoutes.push(errorRoute);
}
}
return viableERoutes;
}, _Kaze_anyErrorHandler = function _Kaze_anyErrorHandler(ctx, error) {
const route = ctx.req.url;
let errorHandler = __classPrivateFieldGet(this, _Kaze_errorMap, "f")[route];
if (errorHandler) {
return errorHandler(ctx, error);
}
const viableERoutes = __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_getPossibleMatchingRoutes).call(this, route, __classPrivateFieldGet(this, _Kaze_errorMap, "f"));
for (let vRoute of viableERoutes) {
errorHandler = __classPrivateFieldGet(this, _Kaze_errorMap, "f")[vRoute];
if (errorHandler) {
return errorHandler(ctx, error);
}
}
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_defaultErrorHandler).call(this, ctx, error);
}, _Kaze_vErrorHandler = function _Kaze_vErrorHandler(ctx, error) {
const route = ctx.req.url;
let errorHandler = __classPrivateFieldGet(this, _Kaze_vErrorMap, "f")[route];
if (errorHandler) {
return errorHandler(ctx, error);
}
const viableERoutes = __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_getPossibleMatchingRoutes).call(this, route, __classPrivateFieldGet(this, _Kaze_vErrorMap, "f"));
for (let vRoute of viableERoutes) {
errorHandler = __classPrivateFieldGet(this, _Kaze_vErrorMap, "f")[vRoute];
if (errorHandler) {
return errorHandler(ctx, error);
}
}
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_defaultVFailedHandler).call(this, ctx, error);
}, _Kaze_appendToMapRouter = function _Kaze_appendToMapRouter(parentRoute, router) {
exports.AcceptedMethods.forEach(method => {
const middlewares = router.fetchMiddlewares();
const normalRoutes = router.fetchRoutes();
normalRoutes.get(method)?.forEach((handlers, route) => {
const fullRoute = parentRoute === "/" ? route : route === "/" ? parentRoute : `${parentRoute}${route}`;
__classPrivateFieldGet(this, _Kaze_router, "f")[method.toLowerCase()](fullRoute, ...middlewares, ...handlers);
});
const dynamicRoutes = router.fetchDynamicRoutes();
dynamicRoutes.get(method)?.forEach((dynRouteInfo, _) => {
const fullRoute = parentRoute === "/" ? dynRouteInfo.fullRoute : dynRouteInfo.fullRoute === "/" ? parentRoute : `${parentRoute}${dynRouteInfo.fullRoute}`;
__classPrivateFieldGet(this, _Kaze_router, "f")[method.toLowerCase()](fullRoute, ...middlewares, ...dynRouteInfo.handlers);
});
});
}, _Kaze_checkFileExists = async function _Kaze_checkFileExists(file) {
try {
const stats = await promises_1.default.lstat(file);
return stats.isFile();
}
catch {
return false;
}
}, _Kaze_readFile = async function _Kaze_readFile(filePath) {
const data = await promises_1.default.readFile(filePath, { encoding: "utf8" });
return data;
}, _Kaze_sendFile = async function _Kaze_sendFile(path) {
const extension = path.split("/").pop()?.split(".")[1];
__classPrivateFieldSet(this, _Kaze_mimeType, (0, utils_1.getMimeType)(extension), "f");
const body = await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_readFile).call(this, path);
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(body), "f");
__classPrivateFieldSet(this, _Kaze_responseData, body, "f");
}, _Kaze_send = function _Kaze_send(data) {
__classPrivateFieldSet(this, _Kaze_mimeType, "text/plain", "f");
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(data), "f");
__classPrivateFieldSet(this, _Kaze_responseData, data, "f");
}, _Kaze_html = function _Kaze_html(htmlSource) {
__classPrivateFieldSet(this, _Kaze_mimeType, "text/html", "f");
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(htmlSource), "f");
__classPrivateFieldSet(this, _Kaze_responseData, htmlSource, "f");
}, _Kaze_json = function _Kaze_json(jsonObj) {
__classPrivateFieldSet(this, _Kaze_mimeType, "application/json", "f");
const data = JSON.stringify(jsonObj);
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(data), "f");
__classPrivateFieldSet(this, _Kaze_responseData, data, "f");
}, _Kaze_render = async function _Kaze_render(file, data) {
const filepath = node_path_1.default.join(__classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderEngineDirPath, __classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderingEngineOptions?.fileExtension ?
`${file}.${__classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderingEngineOptions?.fileExtension}` : file);
const templateData = await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_readFile).call(this, filepath);
const htmlSource = await __classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderEngine({
filepath,
renderEngineDirPath: __classPrivateFieldGet(this, _Kaze_renderingEngineInfo, "f").renderEngineDirPath
}, templateData, data);
return htmlSource;
}, _Kaze_statusCode = function _Kaze_statusCode(code) {
__classPrivateFieldSet(this, _Kaze_respStatusCode, code, "f");
}, _Kaze_handleResponse = function _Kaze_handleResponse(res) {
if (__classPrivateFieldGet(this, _Kaze_responseSent, "f") || res.closed) {
throw new Error("Trying to send more than one response");
}
const respHeaders = {
"content-type": __classPrivateFieldGet(this, _Kaze_mimeType, "f"),
"content-length": __classPrivateFieldGet(this, _Kaze_contentLength, "f"),
};
res.writeHead(__classPrivateFieldGet(this, _Kaze_respStatusCode, "f"), respHeaders).end(__classPrivateFieldGet(this, _Kaze_responseData, "f"));
__classPrivateFieldSet(this, _Kaze_responseSent, true, "f");
}, _Kaze_handleStaticFile = async function _Kaze_handleStaticFile(filePath, response) {
const data = await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_readFile).call(this, filePath);
const extension = filePath.split("/").pop().split(".").pop();
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_statusCode).call(this, 200);
__classPrivateFieldSet(this, _Kaze_mimeType, (0, utils_1.getMimeType)(extension), "f");
__classPrivateFieldSet(this, _Kaze_responseData, data, "f");
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(data), "f");
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
}, _Kaze_handle = async function _Kaze_handle(request, response, dependencies) {
const [route, queries] = request.url?.split("?");
const reqMethod = request.method;
// before any new request is served
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_resetServerState).call(this);
const routes = route.split("/").slice(1);
const filePath = node_path_1.default.join(...routes);
const fullPath = node_path_1.default.join(__classPrivateFieldGet(this, _Kaze_staticDirPath, "f"), filePath);
const isExists = await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_checkFileExists).call(this, fullPath);
if (isExists) {
return __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleStaticFile).call(this, fullPath, response);
}
try {
if (!reqMethod || !route) {
throw new Error("reqMethod or Route is missing in incoming request.");
}
let params = {};
let routeHandlers = await __classPrivateFieldGet(this, _Kaze_router, "f").fetchHandlers(route, reqMethod);
if (typeof routeHandlers === "object" &&
routeHandlers.hasOwnProperty("params")) {
params = routeHandlers["params"];
routeHandlers = routeHandlers["handlers"];
}
if (routeHandlers === undefined) {
routeHandlers = await __classPrivateFieldGet(this, _Kaze_router, "f").fetchHandlers("*", reqMethod);
if (routeHandlers === undefined) {
throw new kaze_errors_1.KazeRouteNotFound(`Route '${route}' not found.`);
}
}
const queriesMap = queries?.split("&").reduce((acc, query) => {
const [key, value] = query.split("=");
acc[key] = value;
return acc;
}, {});
const ctx = {
dependencies,
req: Object.assign(request, {
params: params,
query: queriesMap,
secure: __classPrivateFieldGet(this, _Kaze_isHttps, "f"),
}),
res: Object.assign(response, {
send: (data) => {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_send).call(this, data);
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
},
json: (jsonObj) => {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_json).call(this, jsonObj);
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
},
html: (htmlSource) => {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_html).call(this, htmlSource);
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
},
render: async (file, data) => {
try {
const htmlSource = await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_render).call(this, file, data);
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_html).call(this, htmlSource);
}
catch (error) {
if (error instanceof Error) {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_html).call(this, (0, kaze_utils_1.transformErrorStackToHtml)(error.stack ?? error.message));
}
else {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_html).call(this, (0, kaze_utils_1.transformErrorStackToHtml)("Something went wrong with rendering engine."));
}
}
finally {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
}
},
sendFile: async (path) => {
await __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_sendFile).call(this, path);
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
},
setHeader: response.setHeader,
statusCode: __classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_statusCode).bind(this),
addHeader: (key, value) => {
response.setHeader(key, value);
},
setCookie: (key, value, options) => {
const cookie = (0, kaze_cookies_1.createCookie)(key, value, options);
response.setHeader("Set-Cookie", cookie);
}
}),
};
const allHandlers = [
...__classPrivateFieldGet(this, _Kaze_globalMiddlewares, "f"),
...routeHandlers,
];
function* handlerGen() {
for (let i = 0; i < allHandlers.length; ++i) {
yield allHandlers[i];
}
}
const hGen = handlerGen();
const next = async () => {
let result = hGen.next();
if (!result.done) {
const handler = result.value;
try {
await handler(ctx, next);
}
catch (err) {
if (err instanceof kaze_errors_1.KazeValidationError) {
return __classPrivateFieldGet(this, _Kaze_validationFailedHandler, "f").call(this, ctx, err);
}
else {
return __classPrivateFieldGet(this, _Kaze_errorHandler, "f").call(this, ctx, err);
}
}
}
};
next();
}
catch (err) {
if (err instanceof kaze_errors_1.KazeRouteError ||
err instanceof kaze_errors_1.KazeRouteNotFound) {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_statusCode).call(this, err.statusCode);
__classPrivateFieldSet(this, _Kaze_responseData, (0, kaze_utils_1.transformErrorStackToHtml)(err.stack), "f");
}
else if (err instanceof Error) {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_statusCode).call(this, 500);
__classPrivateFieldSet(this, _Kaze_responseData, (0, kaze_utils_1.transformErrorStackToHtml)(err.stack), "f");
}
__classPrivateFieldSet(this, _Kaze_mimeType, "text/html", "f");
__classPrivateFieldSet(this, _Kaze_contentLength, Buffer.byteLength(__classPrivateFieldGet(this, _Kaze_responseData, "f")), "f");
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_handleResponse).call(this, response);
}
}, _Kaze_resetServerState = function _Kaze_resetServerState() {
__classPrivateFieldGet(this, _Kaze_instances, "m", _Kaze_statusCode).call(this, 200);
__classPrivateFieldSet(this, _Kaze_contentLength, 0, "f");
__classPrivateFieldSet(this, _Kaze_responseData, "", "f");
__classPrivateFieldSet(this, _Kaze_responseSent, false, "f");
__classPrivateFieldSet(this, _Kaze_mimeType, "text/plain", "f");
};
;