@eggjs/onerror 3.0.0 → 3.0.1-beta.1

package/README.md

@@ -1,8 +1,6 @@
 # @eggjs/onerror
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/onerror/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/onerror/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/onerror.svg?style=flat)](https://nodejs.org/en/download/)
@@ -11,8 +9,6 @@
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/onerror.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/onerror
-[codecov-image]: https://codecov.io/github/eggjs/onerror/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/onerror?branch=master
 [snyk-image]: https://snyk.io/test/npm/@eggjs/onerror/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/onerror
 [download-image]: https://img.shields.io/npm/dm/@eggjs/onerror.svg?style=flat-square
@@ -58,10 +54,10 @@ Please open an issue [here](https://github.com/eggjs/egg/issues).
 
 ## License
 
-[MIT](https://github.com/eggjs/onerror/blob/master/LICENSE)
+[MIT](LICENSE)
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/onerror)](https://github.com/eggjs/onerror/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).

package/dist/agent.d.ts

@@ -0,0 +1,10 @@
+import { Agent, ILifecycleBoot } from "egg";
+
+//#region src/agent.d.ts
+declare class Boot implements ILifecycleBoot {
+  private agent;
+  constructor(agent: Agent);
+  didLoad(): Promise<void>;
+}
+//#endregion
+export { Boot as default };

package/dist/agent.js

@@ -0,0 +1,15 @@
+//#region src/agent.ts
+var Boot = class {
+	agent;
+	constructor(agent) {
+		this.agent = agent;
+	}
+	async didLoad() {
+		this.agent.on("error", (err) => {
+			this.agent.coreLogger.error(err);
+		});
+	}
+};
+
+//#endregion
+export { Boot as default };

package/dist/app.d.ts

@@ -0,0 +1,16 @@
+import { OnerrorError } from "koa-onerror";
+import { Application, ILifecycleBoot } from "egg";
+
+//#region src/app.d.ts
+interface OnerrorErrorWithCode extends OnerrorError {
+  code?: string;
+  type?: string;
+  errors?: any[];
+}
+declare class Boot implements ILifecycleBoot {
+  private app;
+  constructor(app: Application);
+  didLoad(): Promise<void>;
+}
+//#endregion
+export { OnerrorErrorWithCode, Boot as default };

package/dist/app.js

@@ -0,0 +1,111 @@
+import { accepts, detectErrorMessage, detectStatus, isProd } from "./lib/utils.js";
+import { ErrorView } from "./lib/error_view.js";
+import http from "node:http";
+import fs from "node:fs";
+import { onerror } from "koa-onerror";
+
+//#region src/app.ts
+var Boot = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	async didLoad() {
+		const config = this.app.config.onerror;
+		const viewTemplate = fs.readFileSync(config.templatePath, "utf8");
+		const app = this.app;
+		app.on("error", (err, ctx) => {
+			if (!ctx) ctx = app.currentContext || app.createAnonymousContext();
+			if (config.appErrorFilter && !config.appErrorFilter(err, ctx)) return;
+			if (detectStatus(err) >= 500) {
+				try {
+					ctx.logger.error(err);
+				} catch (ex) {
+					app.logger.error(err);
+					app.logger.error(ex);
+				}
+				return;
+			}
+			try {
+				ctx.logger.warn(err);
+			} catch (ex) {
+				app.logger.warn(err);
+				app.logger.error(ex);
+			}
+		});
+		const errorOptions = {
+			accepts() {
+				return (config.accepts || accepts)(this);
+			},
+			html(err, ctx) {
+				const status = detectStatus(err);
+				const errorPageUrl = typeof config.errorPageUrl === "function" ? config.errorPageUrl(err, ctx) : config.errorPageUrl;
+				ctx.realStatus = status;
+				if (isProd(app)) {
+					if (status >= 500) {
+						if (errorPageUrl) {
+							const statusQuery = (errorPageUrl.indexOf("?") > 0 ? "&" : "?") + `real_status=${status}`;
+							return ctx.redirect(errorPageUrl + statusQuery);
+						}
+						ctx.status = 500;
+						ctx.body = `<h2>Internal Server Error, real status: ${status}</h2>`;
+						return;
+					}
+					ctx.status = status;
+					ctx.body = `<h2>${status} ${http.STATUS_CODES[status]}</h2>`;
+					return;
+				}
+				if (app.config.env === "unittest") {
+					ctx.status = status;
+					ctx.body = `${err.name}: ${err.message}\n${err.stack}`;
+					return;
+				}
+				ctx.body = new ErrorView(ctx, err, viewTemplate).toHTML();
+			},
+			json(err, ctx) {
+				const status = detectStatus(err);
+				let errorJson = {};
+				ctx.status = status;
+				const code = err.code ?? err.type;
+				const message = detectErrorMessage(ctx, err);
+				if (isProd(app)) if (status >= 500) errorJson = {
+					code,
+					message: http.STATUS_CODES[status]
+				};
+				else errorJson = {
+					code,
+					message,
+					errors: err.errors
+				};
+				else {
+					errorJson = {
+						code,
+						message,
+						errors: err.errors
+					};
+					if (status >= 500) {
+						errorJson.stack = err.stack;
+						errorJson.name = err.name;
+						for (const key in err) if (!errorJson[key]) errorJson[key] = err[key];
+					}
+				}
+				ctx.body = errorJson;
+			},
+			js(err, ctx) {
+				errorOptions.json.call(ctx, err, ctx);
+				if (typeof ctx.createJsonpBody === "function") ctx.createJsonpBody(ctx.body);
+			}
+		};
+		for (const type of [
+			"all",
+			"html",
+			"json",
+			"text",
+			"js"
+		]) if (config[type]) Reflect.set(errorOptions, type, config[type]);
+		onerror(app, errorOptions);
+	}
+};
+
+//#endregion
+export { Boot as default };

package/{src/config/config.default.ts → dist/config/config.default.d.ts}

@@ -1,9 +1,8 @@
-import path from 'node:path';
-import type { Context } from '@eggjs/core';
-import type { OnerrorError, OnerrorOptions } from 'koa-onerror';
-import { getSourceDirname } from '../lib/utils.js';
+import { OnerrorError, OnerrorOptions } from "koa-onerror";
+import { Context } from "egg";
 
-export interface OnerrorConfig extends OnerrorOptions {
+//#region src/config/config.default.d.ts
+interface OnerrorConfig extends OnerrorOptions {
   /**
    * 5xx error will redirect to ${errorPageUrl}
    * won't redirect in local env
@@ -24,11 +23,8 @@ export interface OnerrorConfig extends OnerrorOptions {
    */
   templatePath: string;
 }
-
-export default {
-  onerror: {
-    errorPageUrl: '',
-    appErrorFilter: undefined,
-    templatePath: path.join(getSourceDirname(), 'lib/onerror_page.mustache.html'),
-  } as OnerrorConfig,
+declare const _default: {
+  onerror: OnerrorConfig;
 };
+//#endregion
+export { OnerrorConfig, _default as default };

package/dist/config/config.default.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+
+//#region src/config/config.default.ts
+var config_default_default = { onerror: {
+	errorPageUrl: "",
+	appErrorFilter: void 0,
+	templatePath: path.join(import.meta.dirname, "../lib/onerror_page.mustache.html")
+} };
+
+//#endregion
+export { config_default_default as default };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.js

@@ -0,0 +1 @@
+export {  };

package/dist/lib/error_view.d.ts

@@ -0,0 +1,158 @@
+import { OnerrorError } from "koa-onerror";
+import { StackFrame } from "stack-trace";
+import { Context } from "egg";
+
+//#region src/lib/error_view.d.ts
+interface FrameSource {
+  pre: string[];
+  line: string;
+  post: string[];
+}
+interface Frame extends StackFrame {
+  context?: FrameSource;
+}
+declare class ErrorView {
+  ctx: Context;
+  error: OnerrorError;
+  request: Context['request'];
+  app: Context['app'];
+  assets: Map<string, string>;
+  viewTemplate: string;
+  codeContext: number;
+  _filterHeaders: string[];
+  constructor(ctx: Context, error: OnerrorError, template: string);
+  /**
+   * get html error page
+   *
+   * @return {String} html page
+   */
+  toHTML(): string;
+  /**
+   * compile view
+   *
+   * @param {String} tpl - template
+   * @param {Object} locals - data used by template
+   */
+  compileView(tpl: string, locals: Record<string, unknown>): string;
+  /**
+   * check if the frame is node native file.
+   *
+   * @param {Frame} frame - current frame
+   */
+  isNode(frame: Frame): boolean;
+  /**
+   * check if the frame is app modules.
+   *
+   * @param {Object} frame - current frame
+   */
+  isApp(frame: Frame): boolean;
+  /**
+   * cache file asserts
+   *
+   * @param {String} key - assert key
+   * @param {String} value - assert content
+   */
+  setAssets(key: string, value: string): void;
+  /**
+   * get cache file asserts
+   *
+   * @param {String} key - assert key
+   */
+  getAssets(key: string): string | undefined;
+  /**
+   * get frame source
+   *
+   * @param {Object} frame - current frame
+   */
+  getFrameSource(frame: StackFrame): FrameSource;
+  /**
+   * parse error and return frame stack
+   */
+  parseError(): Frame[];
+  /**
+   * get stack context
+   *
+   * @param {Object} frame - current frame
+   */
+  getContext(frame: Frame): {
+    start?: undefined;
+    pre?: undefined;
+    line?: undefined;
+    post?: undefined;
+  } | {
+    start: number;
+    pre: string;
+    line: string;
+    post: string;
+  };
+  /**
+   * get frame classes, let view identify the frame
+   *
+   * @param {any} frame - current frame
+   * @param {any} index - current index
+   */
+  getFrameClasses(frame: Frame, index: number): string;
+  /**
+   * serialize frame and return meaningful data
+   *
+   * @param {Object} frame - current frame
+   */
+  serializeFrame(frame: Frame): {
+    extname: string;
+    file: string;
+    method: string;
+    line: number;
+    column: number;
+    context: {
+      start?: undefined;
+      pre?: undefined;
+      line?: undefined;
+      post?: undefined;
+    } | {
+      start: number;
+      pre: string;
+      line: string;
+      post: string;
+    };
+    classes: string;
+  };
+  /**
+   * serialize base data
+   *
+   * @param {Object} stack - frame stack
+   * @param {Function} frameFormatter - frame formatter function
+   */
+  serializeData(stack: Frame[], frameFormatter: (frame: Frame, index: number) => any): {
+    code: any;
+    message: string;
+    name: string;
+    status: number;
+    frames: any[];
+  };
+  /**
+   * serialize request object
+   */
+  serializeRequest(): {
+    url: string;
+    httpVersion: string;
+    method: string;
+    connection: string | undefined;
+    headers: {
+      key: string;
+      value: string | string[] | undefined;
+    }[];
+    cookies: {
+      key: string;
+      value: string | undefined;
+    }[];
+  };
+  /**
+   * serialize app info object
+   */
+  serializeAppInfo(): {
+    baseDir: string;
+    config: string;
+  };
+}
+//#endregion
+export { ErrorView, Frame, FrameSource };

package/dist/lib/error_view.js

@@ -0,0 +1,224 @@
+import { detectErrorMessage } from "./utils.js";
+import fs from "node:fs";
+import path from "node:path";
+import util from "node:util";
+import { parse } from "cookie";
+import Mustache from "mustache";
+import stackTrace from "stack-trace";
+
+//#region src/lib/error_view.ts
+const startingSlashRegex = /\\|\//;
+var ErrorView = class {
+	ctx;
+	error;
+	request;
+	app;
+	assets;
+	viewTemplate;
+	codeContext = 5;
+	_filterHeaders = ["cookie", "connection"];
+	constructor(ctx, error, template) {
+		this.ctx = ctx;
+		this.error = error;
+		this.request = ctx.request;
+		this.app = ctx.app;
+		this.assets = /* @__PURE__ */ new Map();
+		this.viewTemplate = template;
+	}
+	/**
+	* get html error page
+	*
+	* @return {String} html page
+	*/
+	toHTML() {
+		const stack = this.parseError();
+		const data = this.serializeData(stack, (frame, index) => {
+			const serializedFrame = this.serializeFrame(frame);
+			serializedFrame.classes = this.getFrameClasses(frame, index);
+			return serializedFrame;
+		});
+		return this.compileView(this.viewTemplate, {
+			...data,
+			appInfo: this.serializeAppInfo(),
+			request: this.serializeRequest()
+		});
+	}
+	/**
+	* compile view
+	*
+	* @param {String} tpl - template
+	* @param {Object} locals - data used by template
+	*/
+	compileView(tpl, locals) {
+		return Mustache.render(tpl, locals);
+	}
+	/**
+	* check if the frame is node native file.
+	*
+	* @param {Frame} frame - current frame
+	*/
+	isNode(frame) {
+		if (frame.isNative()) return true;
+		const filename = frame.getFileName() || "";
+		return !path.isAbsolute(filename) && filename[0] !== ".";
+	}
+	/**
+	* check if the frame is app modules.
+	*
+	* @param {Object} frame - current frame
+	*/
+	isApp(frame) {
+		if (this.isNode(frame)) return false;
+		return !(frame.getFileName() || "").includes("node_modules" + path.sep);
+	}
+	/**
+	* cache file asserts
+	*
+	* @param {String} key - assert key
+	* @param {String} value - assert content
+	*/
+	setAssets(key, value) {
+		this.assets.set(key, value);
+	}
+	/**
+	* get cache file asserts
+	*
+	* @param {String} key - assert key
+	*/
+	getAssets(key) {
+		return this.assets.get(key);
+	}
+	/**
+	* get frame source
+	*
+	* @param {Object} frame - current frame
+	*/
+	getFrameSource(frame) {
+		const filename = frame.getFileName();
+		const lineNumber = frame.getLineNumber();
+		let contents = this.getAssets(filename);
+		if (!contents) {
+			contents = fs.existsSync(filename) ? fs.readFileSync(filename, "utf8") : "";
+			this.setAssets(filename, contents);
+		}
+		const lines = contents.split(/\r?\n/);
+		return {
+			pre: lines.slice(Math.max(0, lineNumber - (this.codeContext + 1)), lineNumber - 1),
+			line: lines[lineNumber - 1],
+			post: lines.slice(lineNumber, lineNumber + this.codeContext)
+		};
+	}
+	/**
+	* parse error and return frame stack
+	*/
+	parseError() {
+		return stackTrace.parse(this.error).map((frame) => {
+			if (!this.isNode(frame)) frame.context = this.getFrameSource(frame);
+			return frame;
+		});
+	}
+	/**
+	* get stack context
+	*
+	* @param {Object} frame - current frame
+	*/
+	getContext(frame) {
+		if (!frame.context) return {};
+		return {
+			start: frame.getLineNumber() - (frame.context.pre || []).length,
+			pre: frame.context.pre.join("\n"),
+			line: frame.context.line,
+			post: frame.context.post.join("\n")
+		};
+	}
+	/**
+	* get frame classes, let view identify the frame
+	*
+	* @param {any} frame - current frame
+	* @param {any} index - current index
+	*/
+	getFrameClasses(frame, index) {
+		const classes = [];
+		if (index === 0) classes.push("active");
+		if (!this.isApp(frame)) classes.push("native-frame");
+		return classes.join(" ");
+	}
+	/**
+	* serialize frame and return meaningful data
+	*
+	* @param {Object} frame - current frame
+	*/
+	serializeFrame(frame) {
+		const filename = frame.getFileName();
+		const relativeFileName = filename.includes(process.cwd()) ? filename.replace(process.cwd(), "").replace(startingSlashRegex, "") : filename;
+		return {
+			extname: path.extname(filename).replace(".", ""),
+			file: relativeFileName,
+			method: frame.getFunctionName(),
+			line: frame.getLineNumber(),
+			column: frame.getColumnNumber(),
+			context: this.getContext(frame),
+			classes: ""
+		};
+	}
+	/**
+	* serialize base data
+	*
+	* @param {Object} stack - frame stack
+	* @param {Function} frameFormatter - frame formatter function
+	*/
+	serializeData(stack, frameFormatter) {
+		const code = Reflect.get(this.error, "code") ?? Reflect.get(this.error, "type");
+		let message = detectErrorMessage(this.ctx, this.error);
+		if (code) message = `${message} (code: ${code})`;
+		return {
+			code,
+			message,
+			name: this.error.name,
+			status: this.error.status,
+			frames: stack instanceof Array ? stack.filter((frame) => frame.getFileName()).map(frameFormatter) : []
+		};
+	}
+	/**
+	* serialize request object
+	*/
+	serializeRequest() {
+		const headers = [];
+		Object.keys(this.request.headers).forEach((key) => {
+			if (this._filterHeaders.includes(key)) return;
+			headers.push({
+				key,
+				value: this.request.headers[key]
+			});
+		});
+		const parsedCookies = parse(this.request.headers.cookie || "");
+		const cookies = Object.keys(parsedCookies).map((key) => {
+			return {
+				key,
+				value: parsedCookies[key]
+			};
+		});
+		return {
+			url: this.request.url,
+			httpVersion: this.request.req.httpVersion,
+			method: this.request.method,
+			connection: this.request.headers.connection,
+			headers,
+			cookies
+		};
+	}
+	/**
+	* serialize app info object
+	*/
+	serializeAppInfo() {
+		let config = this.app.config;
+		if ("dumpConfigToObject" in this.app && typeof this.app.dumpConfigToObject === "function") config = this.app.dumpConfigToObject().config.config;
+		return {
+			baseDir: this.app.config.baseDir,
+			config: util.inspect(config)
+		};
+	}
+};
+
+//#endregion
+export { ErrorView };

package/dist/{commonjs/lib → lib}/onerror_page.mustache.html

@@ -676,7 +676,7 @@
             <pre class="line-numbers"><code class="language-json">{{ appInfo.config }}</code></pre>
           </div>
         </div>
-      </<div>
+      </div>
     </section>
 
     <script type="text/javascript">

package/dist/lib/utils.d.ts

@@ -0,0 +1,10 @@
+import { OnerrorError } from "koa-onerror";
+import { Application, Context } from "egg";
+
+//#region src/lib/utils.d.ts
+declare function detectErrorMessage(ctx: Context, err: OnerrorError): string;
+declare function detectStatus(err: OnerrorError): number;
+declare function accepts(ctx: Context): "json" | "js" | "html";
+declare function isProd(app: Application): boolean;
+//#endregion
+export { accepts, detectErrorMessage, detectStatus, isProd };

package/dist/lib/utils.js

@@ -0,0 +1,21 @@
+//#region src/lib/utils.ts
+function detectErrorMessage(ctx, err) {
+	if (err.status === 400 && err.name === "SyntaxError" && ctx.request.is("application/json", "application/vnd.api+json", "application/csp-report")) return "Problems parsing JSON";
+	return err.message;
+}
+function detectStatus(err) {
+	let status = err.status || 500;
+	if (status < 200) status = 500;
+	return status;
+}
+function accepts(ctx) {
+	if (ctx.acceptJSON) return "json";
+	if (ctx.acceptJSONP) return "js";
+	return "html";
+}
+function isProd(app) {
+	return app.config.env !== "local" && app.config.env !== "unittest";
+}
+
+//#endregion
+export { accepts, detectErrorMessage, detectStatus, isProd };

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import { OnerrorConfig } from "./config/config.default.js";
+
+//#region src/types.d.ts
+declare module 'egg' {
+  interface EggAppConfig {
+    onerror: OnerrorConfig;
+  }
+}
+//#endregion
+export { type OnerrorConfig };

package/dist/types.js

@@ -0,0 +1 @@
+export {  };