988278265

Build Type

push

github

Committed by James Messinger

Commit Message

ESLint fixes (renamed all generic params)

Run Details

80 of 103 branches covered (77.67%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 5 files covered. (100.0%)

22 existing lines in 3 files now uncovered.

111 of 133 relevant lines covered (83.46%)

138.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.5

/src/extend-error.ts

import { addInspectMethod } from "./isomorphic.node";
import { isLazyStack, isWritableStack, joinStacks, lazyJoinStacks } from "./stack";
import { getDeepKeys, toJSON } from "./to-json";
import { ErrorLike, ErrorPOJO, OnoError } from "./types";

const protectedProps: Array<string | symbol> = ["name", "message", "stack"];

/**
 * Extends the new error with the properties of the original error and the `props` object.
 *
 * @param newError - The error object to extend
 * @param originalError - The original error object, if any
 * @param props - Additional properties to add, if any
 */
export function extendError<TError extends ErrorLike, TOriginal extends ErrorLike, TProps extends object>(
  error: TError, originalError?: TOriginal, props?: TProps) {

  let onoError = error as unknown as TError & TOriginal & TProps & OnoError<TError & TOriginal & TProps>;

  extendStack(onoError, originalError);

  // Copy properties from the original error
  if (originalError && typeof originalError === "object") {
    mergeErrors(onoError, originalError);
  }

  // The default `toJSON` method doesn't output props like `name`, `message`, `stack`, etc.
  // So replace it with one that outputs every property of the error.
  onoError.toJSON = toJSON;

  // On Node.js, add support for the `util.inspect()` method
  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
  if (addInspectMethod) {
    addInspectMethod(onoError);
  }

  // Finally, copy custom properties that were specified by the user.
  // These props OVERWRITE any previous props
  if (props && typeof props === "object") {
    Object.assign(onoError, props);
  }

  return onoError;
}

/**
 * Extend the error stack to include its cause
 */
function extendStack(newError: ErrorLike, originalError?: ErrorPOJO): void {
  let stackProp = Object.getOwnPropertyDescriptor(newError, "stack");

  if (isLazyStack(stackProp)) {
    lazyJoinStacks(stackProp, newError, originalError);
  }
  else if (isWritableStack(stackProp)) {
    newError.stack = joinStacks(newError, originalError);
  }
}

/**
 * Merges properties of the original error with the new error.
 *
 * @param newError - The error object to extend
 * @param originalError - The original error object, if any
 */
function mergeErrors(newError: ErrorLike, originalError: ErrorPOJO) {
  // Get the original error's keys
  // NOTE: We specifically exclude properties that we have already set on the new error.
  // This is _especially_ important for the `stack` property, because this property has
  // a lazy getter in some environments
  let keys = getDeepKeys(originalError, protectedProps);

  // HACK: We have to cast the errors to `any` so we can use symbol indexers.
  // see https://github.com/Microsoft/TypeScript/issues/1863
  let _newError = newError as any;
  let _originalError = originalError as any;

  for (let key of keys) {
    if (_newError[key] === undefined) {
      try {
        _newError[key] = _originalError[key];
      }
      catch (e) {
        // This property is read-only, so it can't be copied
      }
    }
  }
}

1	import { addInspectMethod } from "./isomorphic.node";
2	import { isLazyStack, isWritableStack, joinStacks, lazyJoinStacks } from "./stack";
3	import { getDeepKeys, toJSON } from "./to-json";
4	import { ErrorLike, ErrorPOJO, OnoError } from "./types";
5
6	const protectedProps: Array<string \| symbol> = ["name", "message", "stack"];	8✔
7
8	/**
9	* Extends the new error with the properties of the original error and the `props` object.
10	*
11	* @param newError - The error object to extend
12	* @param originalError - The original error object, if any
13	* @param props - Additional properties to add, if any
14	*/
15	export function extendError<TError extends ErrorLike, TOriginal extends ErrorLike, TProps extends object>(
16	error: TError, originalError?: TOriginal, props?: TProps) {
17
18	let onoError = error as unknown as TError & TOriginal & TProps & OnoError<TError & TOriginal & TProps>;	237✔
19
20	extendStack(onoError, originalError);	237✔
21
22	// Copy properties from the original error
23	if (originalError && typeof originalError === "object") {	235✔
24	mergeErrors(onoError, originalError);	108✔
25	}
26
27	// The default `toJSON` method doesn't output props like `name`, `message`, `stack`, etc.
28	// So replace it with one that outputs every property of the error.
29	onoError.toJSON = toJSON;	235✔
30
31	// On Node.js, add support for the `util.inspect()` method
32	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
33	if (addInspectMethod) {	235!
UNCOV 34	addInspectMethod(onoError);	×
35	}
36
37	// Finally, copy custom properties that were specified by the user.
38	// These props OVERWRITE any previous props
39	if (props && typeof props === "object") {	235✔
40	Object.assign(onoError, props);	116✔
41	}
42
43	return onoError;	235✔
44	}
45
46	/**
47	* Extend the error stack to include its cause
48	*/
49	function extendStack(newError: ErrorLike, originalError?: ErrorPOJO): void {
50	let stackProp = Object.getOwnPropertyDescriptor(newError, "stack");	237✔
51
52	if (isLazyStack(stackProp)) {	235!
UNCOV 53	lazyJoinStacks(stackProp, newError, originalError);	×
54	}
55	else if (isWritableStack(stackProp)) {	235!
56	newError.stack = joinStacks(newError, originalError);	235✔
57	}
58	}
59
60	/**
61	* Merges properties of the original error with the new error.
62	*
63	* @param newError - The error object to extend
64	* @param originalError - The original error object, if any
65	*/
66	function mergeErrors(newError: ErrorLike, originalError: ErrorPOJO) {	324✔
67	// Get the original error's keys
68	// NOTE: We specifically exclude properties that we have already set on the new error.
69	// This is _especially_ important for the `stack` property, because this property has
70	// a lazy getter in some environments
71	let keys = getDeepKeys(originalError, protectedProps);	108✔
72
73	// HACK: We have to cast the errors to `any` so we can use symbol indexers.
74	// see https://github.com/Microsoft/TypeScript/issues/1863
75	let _newError = newError as any;	108✔
76	let _originalError = originalError as any;	108✔
77
78	for (let key of keys) {	260✔
79	if (_newError[key] === undefined) {	260✔
80	try {	192✔
81	_newError[key] = _originalError[key];	192✔
82	}
83	catch (e) {
84	// This property is read-only, so it can't be copied
85	}
86	}
87	}
88	}

JS-DevTools / ono / 988278265

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous