rename and refactor walk

Author: lobsterkatie

packages/utils/src/normalize.ts

@@ -1,10 +1,16 @@
-import { isPrimitive, isSyntheticEvent } from './is';
+import { Primitive } from '@sentry/types';
+
+import { isError, isEvent, isNaN, isSyntheticEvent } from './is';
 import { memoBuilder, MemoFunc } from './memo';
 import { convertToPlainObject } from './object';
 import { getFunctionName } from './stacktrace';
 
-type UnknownMaybeWithToJson = unknown & { toJSON?: () => string };
 type Prototype = { constructor: (...args: unknown[]) => unknown };
+// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we
+// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this
+// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them
+// might be arrays.
+type ObjOrArray<T> = { [key: string]: T };
 
 /**
  * Recursively normalizes the given object.
@@ -28,7 +34,7 @@ type Prototype = { constructor: (...args: unknown[]) => unknown };
 export function normalize(input: unknown, depth: number = +Infinity, maxProperties: number = +Infinity): any {
   try {
     // since we're at the outermost level, there is no key
-    return walk('', input as UnknownMaybeWithToJson, depth, maxProperties);
+    return visit('', input, depth, maxProperties);
   } catch (_oO) {
     return '**non-serializable**';
   }
@@ -52,80 +58,95 @@ export function normalizeToSize<T>(
 }
 
 /**
- * Walks an object to perform a normalization on it
+ * Visits a node to perform normalization on it
  *
- * @param key of object that's walked in current iteration
- * @param value object to be walked
- * @param depth Optional number indicating how deep should walking be performed
- * @param maxProperties Optional maximum  number of properties/elements included in any single object/array
+ * @param key The key corresponding to the given node
+ * @param value The node to be visited
+ * @param depth Optional number indicating the maximum recursion depth
+ * @param maxProperties Optional maximum number of properties/elements included in any single object/array
  * @param memo Optional Memo class handling decycling
  */
-export function walk(
+function visit(
   key: string,
-  value: UnknownMaybeWithToJson,
+  value: unknown,
   depth: number = +Infinity,
   maxProperties: number = +Infinity,
   memo: MemoFunc = memoBuilder(),
-): unknown {
+): Primitive | ObjOrArray<unknown> {
   const [memoize, unmemoize] = memo;
 
-  // If we reach the maximum depth, serialize whatever is left
-  if (depth === 0) {
-    return stringifyValue(key, value);
+  // If the value has a `toJSON` method, see if we can bail and let it do the work
+  const valueWithToJSON = value as unknown & { toJSON?: () => Primitive | ObjOrArray<unknown> };
+  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+    try {
+      return valueWithToJSON.toJSON();
+    } catch (err) {
+      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+    }
   }
 
-  // If value implements `toJSON` method, call it and return early
-  if (value !== null && value !== undefined && typeof value.toJSON === 'function') {
-    return value.toJSON();
+  // Get the simple cases out of the way first
+  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {
+    return value as Primitive;
   }
 
-  // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
-  // pass-through. If what comes back is a primitive (either because it's been stringified or because it was primitive
-  // all along), we're done.
-  const serializable = stringifyValue(key, value);
-  if (isPrimitive(serializable)) {
-    return serializable;
-  }
+  const stringified = stringifyValue(key, value);
 
-  // Create source that we will use for the next iteration. It will either be an objectified error object (`Error` type
-  // with extracted key:value pairs) or the input itself.
-  const source = convertToPlainObject(value);
+  // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+  // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
+  }
 
-  // Create an accumulator that will act as a parent for all future itterations of that branch
-  const acc: { [key: string]: any } = Array.isArray(value) ? [] : {};
+  // We're also done if we've reached the max depth
+  if (depth === 0) {
+    // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+    return stringified.replace('object ', '');
+  }
 
-  // If we already walked that branch, bail out, as it's circular reference
+  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
   if (memoize(value)) {
     return '[Circular ~]';
   }
 
-  let propertyCount = 0;
-  // Walk all keys of the source
-  for (const innerKey in source) {
+  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+  // property/entry, and keep track of the number of items we add to it.
+  const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray<unknown>;
+  let numAdded = 0;
+
+  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+  // properties are non-enumerable and otherwise would get missed.
+  const visitable = (isError(value) || isEvent(value) ? convertToPlainObject(value) : value) as ObjOrArray<unknown>;
+
+  for (const visitKey in visitable) {
     // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
-    if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
+    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
       continue;
     }
 
-    if (propertyCount >= maxProperties) {
-      acc[innerKey] = '[MaxProperties ~]';
+    if (numAdded >= maxProperties) {
+      normalized[visitKey] = '[MaxProperties ~]';
       break;
     }
 
-    propertyCount += 1;
+    // Recursively visit all the child nodes
+    const visitValue = visitable[visitKey];
+    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);
 
-    // Recursively walk through all the child nodes
-    const innerValue = source[innerKey] as UnknownMaybeWithToJson;
-    acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
+    numAdded += 1;
   }
 
-  // Once walked through all the branches, remove the parent from memo storage
+  // Once we've visited all the branches, remove the parent from memo storage
   unmemoize(value);
 
   // Return accumulated values
-  return acc;
+  return normalized;
 }
 
+// TODO remove this in v7 (this means the method will no longer be exported, under any name)
+export { visit as walk };
+
 /**
  * Stringify the given value. Handles various known special values and types.
  *