@eggjs/onerror 3.0.0

package/dist/esm/lib/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Context, EggCore } from '@eggjs/core';
+import type { OnerrorError } from 'koa-onerror';
+export declare function detectErrorMessage(ctx: Context, err: OnerrorError): string;
+export declare function detectStatus(err: OnerrorError): number;
+export declare function accepts(ctx: Context): "json" | "js" | "html";
+export declare function isProd(app: EggCore): boolean;
+/**
+ * Get the source directory name
+ */
+export declare function getSourceDirname(): string;

package/dist/esm/lib/utils.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function detectErrorMessage(ctx, err) {
+    // detect json parse error
+    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;
+}
+export function detectStatus(err) {
+    // detect status
+    let status = err.status || 500;
+    if (status < 200) {
+        // invalid status consider as 500, like urllib will return -1 status
+        status = 500;
+    }
+    return status;
+}
+export function accepts(ctx) {
+    if (ctx.acceptJSON)
+        return 'json';
+    if (ctx.acceptJSONP)
+        return 'js';
+    return 'html';
+}
+export function isProd(app) {
+    return app.config.env !== 'local' && app.config.env !== 'unittest';
+}
+/**
+ * Get the source directory name
+ */
+export function getSourceDirname() {
+    if (typeof __dirname === 'string') {
+        return path.dirname(__dirname);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const __filename = fileURLToPath(import.meta.url);
+    return path.dirname(path.dirname(__filename));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUM3QixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBSXpDLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxHQUFZLEVBQUUsR0FBaUI7SUFDaEUsMEJBQTBCO0lBQzFCLElBQUksR0FBRyxDQUFDLE1BQU0sS0FBSyxHQUFHO1FBQ2xCLEdBQUcsQ0FBQyxJQUFJLEtBQUssYUFBYTtRQUMxQixHQUFHLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSwwQkFBMEIsRUFBRSx3QkFBd0IsQ0FBQyxFQUFFLENBQUM7UUFDN0YsT0FBTyx1QkFBdUIsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDO0FBQ3JCLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWSxDQUFDLEdBQWlCO0lBQzVDLGdCQUFnQjtJQUNoQixJQUFJLE1BQU0sR0FBRyxHQUFHLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQztJQUMvQixJQUFJLE1BQU0sR0FBRyxHQUFHLEVBQUUsQ0FBQztRQUNqQixvRUFBb0U7UUFDcEUsTUFBTSxHQUFHLEdBQUcsQ0FBQztJQUNmLENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQsTUFBTSxVQUFVLE9BQU8sQ0FBQyxHQUFZO0lBQ2xDLElBQUksR0FBRyxDQUFDLFVBQVU7UUFBRSxPQUFPLE1BQU0sQ0FBQztJQUNsQyxJQUFJLEdBQUcsQ0FBQyxXQUFXO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDakMsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQUVELE1BQU0sVUFBVSxNQUFNLENBQUMsR0FBWTtJQUNqQyxPQUFPLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxLQUFLLE9BQU8sSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsS0FBSyxVQUFVLENBQUM7QUFDckUsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQjtJQUM5QixJQUFJLE9BQU8sU0FBUyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ2xDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsNkRBQTZEO0lBQzdELGFBQWE7SUFDYixNQUFNLFVBQVUsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO0FBQ2hELENBQUMifQ==

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,7 @@
+import type { OnerrorConfig } from './config/config.default.js';
+export type { OnerrorConfig };
+declare module '@eggjs/core' {
+    interface EggAppConfig {
+        onerror: OnerrorConfig;
+    }
+}

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@eggjs/onerror",
+  "version": "3.0.0"
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@eggjs/onerror",
+  "version": "3.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "error handler for egg",
+  "eggPlugin": {
+    "name": "onerror",
+    "optionalDependencies": [
+      "jsonp"
+    ],
+    "exports": {
+      "import": "./dist/esm",
+      "require": "./dist/commonjs",
+      "typescript": "./src"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eggjs/onerror.git"
+  },
+  "keywords": [
+    "egg",
+    "egg-plugin",
+    "onerror"
+  ],
+  "author": "dead_horse",
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "dependencies": {
+    "@eggjs/core": "^6.3.1",
+    "cookie": "^1.0.2",
+    "koa-onerror": "^5.0.1",
+    "mustache": "^4.2.0",
+    "stack-trace": "^0.0.10"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.3",
+    "@eggjs/bin": "7",
+    "@eggjs/mock": "^6.0.5",
+    "@eggjs/tsconfig": "1",
+    "@types/mocha": "10",
+    "@types/mustache": "^4.2.5",
+    "@types/node": "22",
+    "@types/stack-trace": "^0.0.33",
+    "egg": "^4.0.4",
+    "eslint": "8",
+    "eslint-config-egg": "14",
+    "rimraf": "6",
+    "tshy": "3",
+    "tshy-after": "1",
+    "typescript": "5"
+  },
+  "scripts": {
+    "lint": "eslint --cache src test --ext .ts",
+    "pretest": "npm run clean && npm run lint -- --fix",
+    "test": "egg-bin test",
+    "preci": "npm run clean &&  npm run lint",
+    "ci": "egg-bin cov",
+    "postci": "npm run prepublishOnly && npm run clean",
+    "clean": "rimraf dist",
+    "prepublishOnly": "tshy && tshy-after && attw --pack"
+  },
+  "type": "module",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./package.json": "./package.json"
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js"
+}

package/src/agent.ts

@@ -0,0 +1,12 @@
+import type { ILifecycleBoot, EggCore } from '@eggjs/core';
+
+export default class Boot implements ILifecycleBoot {
+  constructor(private agent: EggCore) {}
+
+  async didLoad() {
+    // should watch error event
+    this.agent.on('error', err => {
+      this.agent.coreLogger.error(err);
+    });
+  }
+}

package/src/app.ts

@@ -0,0 +1,160 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import { onerror, type OnerrorOptions, type OnerrorError } from 'koa-onerror';
+import type { ILifecycleBoot, EggCore, Context } from '@eggjs/core';
+import { ErrorView } from './lib/error_view.js';
+import { isProd, detectStatus, detectErrorMessage, accepts } from './lib/utils.js';
+import type { OnerrorConfig } from './config/config.default.js';
+
+export interface OnerrorErrorWithCode extends OnerrorError {
+  code?: string;
+  type?: string;
+  errors?: any[];
+}
+
+export default class Boot implements ILifecycleBoot {
+  constructor(private app: EggCore) {}
+
+  async didLoad() {
+    // logging error
+    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;
+
+      const status = detectStatus(err);
+      // 5xx
+      if (status >= 500) {
+        try {
+          ctx.logger.error(err);
+        } catch (ex) {
+          app.logger.error(err);
+          app.logger.error(ex);
+        }
+        return;
+      }
+
+      // 4xx
+      try {
+        ctx.logger.warn(err);
+      } catch (ex) {
+        app.logger.warn(err);
+        app.logger.error(ex);
+      }
+    });
+
+    const errorOptions: OnerrorOptions = {
+      // support customize accepts function
+      accepts(this: Context) {
+        const fn = config.accepts || accepts;
+        return fn(this as any);
+      },
+
+      html(err, ctx: Context) {
+        const status = detectStatus(err);
+        const errorPageUrl = typeof config.errorPageUrl === 'function'
+          ? config.errorPageUrl(err, ctx)
+          : config.errorPageUrl;
+
+        // keep the real response status
+        ctx.realStatus = status;
+        // don't respond any error message in production env
+        if (isProd(app)) {
+          // 5xx
+          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;
+          }
+          // 4xx
+          ctx.status = status;
+          ctx.body = `<h2>${status} ${http.STATUS_CODES[status]}</h2>`;
+          return;
+        }
+        // show simple error format for unittest
+        if (app.config.env === 'unittest') {
+          ctx.status = status;
+          ctx.body = `${err.name}: ${err.message}\n${err.stack}`;
+          return;
+        }
+
+        const errorView = new ErrorView(ctx, err, viewTemplate);
+        ctx.body = errorView.toHTML();
+      },
+
+      json(err: OnerrorErrorWithCode, ctx: Context) {
+        const status = detectStatus(err);
+        let errorJson: Record<string, any> = {};
+
+        ctx.status = status;
+        const code = err.code ?? err.type;
+        const message = detectErrorMessage(ctx, err);
+
+        if (isProd(app)) {
+          // 5xx server side error
+          if (status >= 500) {
+            errorJson = {
+              code,
+              // don't respond any error message in production env
+              message: http.STATUS_CODES[status],
+            };
+          } else {
+            // 4xx client side error
+            // addition `errors`
+            errorJson = {
+              code,
+              message,
+              errors: err.errors,
+            };
+          }
+        } else {
+          errorJson = {
+            code,
+            message,
+            errors: err.errors,
+          };
+
+          if (status >= 500) {
+            // provide detail error stack in local env
+            errorJson.stack = err.stack;
+            errorJson.name = err.name;
+            for (const key in err) {
+              if (!errorJson[key]) {
+                errorJson[key] = (err as any)[key];
+              }
+            }
+          }
+        }
+
+        ctx.body = errorJson;
+      },
+
+      js(err, ctx: Context) {
+        errorOptions.json!.call(ctx, err, ctx);
+
+        if (ctx.createJsonpBody) {
+          ctx.createJsonpBody(ctx.body);
+        }
+      },
+    };
+
+    // support customize error response
+    const keys: (keyof OnerrorConfig)[] = [ 'all', 'html', 'json', 'text', 'js' ];
+    for (const type of keys) {
+      if (config[type]) {
+        Reflect.set(errorOptions, type, config[type]);
+      }
+    }
+    onerror(app, errorOptions);
+  }
+}

package/src/config/config.default.ts

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import type { Context } from '@eggjs/core';
+import type { OnerrorError, OnerrorOptions } from 'koa-onerror';
+import { getSourceDirname } from '../lib/utils.js';
+
+export interface OnerrorConfig extends OnerrorOptions {
+  /**
+   * 5xx error will redirect to ${errorPageUrl}
+   * won't redirect in local env
+   *
+   * Default: `''`
+   */
+  errorPageUrl: string | ((err: OnerrorError, ctx: Context) => string);
+  /**
+   * will execute `appErrorFilter` when emit an error in `app`
+   * If `appErrorFilter` return false, egg-onerror won't log this error.
+   * You can logging in `appErrorFilter` and return false to override the default error logging.
+   *
+   * Default: `undefined`
+   */
+  appErrorFilter?: (err: OnerrorError, ctx: Context) => boolean;
+  /**
+   * default template path
+   */
+  templatePath: string;
+}
+
+export default {
+  onerror: {
+    errorPageUrl: '',
+    appErrorFilter: undefined,
+    templatePath: path.join(getSourceDirname(), 'lib/onerror_page.mustache.html'),
+  } as OnerrorConfig,
+};

package/src/index.ts

@@ -0,0 +1 @@
+import './types.js';

package/src/lib/error_view.ts

@@ -0,0 +1,281 @@
+// modify from https://github.com/poppinss/youch/blob/develop/src/Youch/index.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, { type StackFrame } from 'stack-trace';
+import { detectErrorMessage } from './utils.js';
+import type { OnerrorError } from 'koa-onerror';
+import type { Context } from '@eggjs/core';
+
+const startingSlashRegex = /\\|\//;
+
+export interface FrameSource {
+  pre: string[];
+  line: string;
+  post: string[];
+}
+
+export interface Frame extends StackFrame {
+  context?: FrameSource;
+}
+
+export class ErrorView {
+  ctx: Context;
+  error: OnerrorError;
+  request: Context['request'];
+  app: Context['app'];
+  assets: Map<string, string>;
+  viewTemplate: string;
+
+  codeContext = 5;
+  _filterHeaders = [ 'cookie', 'connection' ];
+
+  constructor(ctx: Context, error: OnerrorError, template: string) {
+    this.ctx = ctx;
+    this.error = error;
+    this.request = ctx.request;
+    this.app = ctx.app;
+    this.assets = new Map();
+    this.viewTemplate = template;
+  }
+
+  /**
+   * get html error page
+   *
+   * @return {String} html page
+   */
+  toHTML(): string {
+    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: string, locals: Record<string, unknown>) {
+    return Mustache.render(tpl, locals);
+  }
+
+  /**
+   * check if the frame is node native file.
+   *
+   * @param {Frame} frame - current frame
+   */
+  isNode(frame: 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: Frame) {
+    if (this.isNode(frame)) {
+      return false;
+    }
+    const filename = frame.getFileName() || '';
+    return !filename.includes('node_modules' + path.sep);
+  }
+
+  /**
+   * cache file asserts
+   *
+   * @param {String} key - assert key
+   * @param {String} value - assert content
+   */
+  setAssets(key: string, value: string) {
+    this.assets.set(key, value);
+  }
+
+  /**
+   * get cache file asserts
+   *
+   * @param {String} key - assert key
+   */
+  getAssets(key: string) {
+    return this.assets.get(key);
+  }
+
+  /**
+   * get frame source
+   *
+   * @param {Object} frame - current frame
+   */
+  getFrameSource(frame: StackFrame): FrameSource {
+    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() {
+    const stack = stackTrace.parse(this.error);
+    return stack.map((frame: Frame) => {
+      if (!this.isNode(frame)) {
+        frame.context = this.getFrameSource(frame);
+      }
+      return frame;
+    });
+  }
+
+  /**
+   * get stack context
+   *
+   * @param {Object} frame - current frame
+   */
+  getContext(frame: 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: Frame, index: number) {
+    const classes: string[] = [];
+    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: Frame) {
+    const filename = frame.getFileName();
+    const relativeFileName = filename.includes(process.cwd())
+      ? filename.replace(process.cwd(), '').replace(startingSlashRegex, '')
+      : filename;
+    const extname = path.extname(filename).replace('.', '');
+
+    return {
+      extname,
+      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: Frame[], frameFormatter: (frame: Frame, index: number) => any) {
+    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: { key: string; value: string | string[] | undefined }[] = [];
+
+    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 as string,
+      config: util.inspect(config),
+    };
+  }
+}
+