core: add wrapMethod util

Author: isaacs

packages/core/src/utils/object.ts

@@ -18,6 +18,7 @@ import { isElement, isError, isEvent, isInstanceOf, isPrimitive } from './is';
  * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.
  * @returns void
  */
+
 export function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {
   if (!(name in source)) {
     return;
@@ -80,6 +81,37 @@ export function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedF
   } catch {} // eslint-disable-line no-empty
 }
 
+/**
+ * Wrap a method on an object by name, only if it is not already wrapped.
+ *
+ * Note: to set the wrapped method as a non-enumerable property, pass
+ * false as the `enumerable` argument. This could be detected, but only
+ * by either walking up the prototype chain, or iterating over all fields
+ * in a `for(in)` loop. Neither are an acceptable performance impact for
+ * the rare case where we might patch a non-enumerable method.
+ */
+export function wrapMethod<O extends {}, T extends string & keyof O>(
+  obj: O,
+  field: T,
+  wrapped: WrappedFunction,
+  enumerable: boolean = true,
+): void {
+  const original = obj[field];
+  if (typeof original !== 'function') {
+    throw new Error(`Cannot wrap method: ${field} is not a function`);
+  }
+  if (getOriginalFunction(original)) {
+    throw new Error(`Attempting to wrap method ${field} multiple times`);
+  }
+  markFunctionWrapped(wrapped, original);
+  Object.defineProperty(obj, field, {
+    writable: true,
+    configurable: true,
+    enumerable,
+    value: wrapped,
+  });
+}
+
 /**
  * This extracts the original function if available.  See
  * `markFunctionWrapped` for more information.

packages/core/test/lib/utils/object.test.ts

@@ -11,6 +11,7 @@ import {
   fill,
   markFunctionWrapped,
   objectify,
+  wrapMethod,
 } from '../../../src/utils/object';
 import { testOnlyIfNodeVersionAtLeast } from '../../testutils';
 
@@ -455,3 +456,47 @@ describe('markFunctionWrapped', () => {
     expect(originalFunc).not.toHaveBeenCalled();
   });
 });
+
+describe('wrapMethod', () => {
+  it('can wrap a method on an object', () => {
+    const wrappedEnumerable = () => {};
+    const originalEnumerable = () => {};
+    const wrappedNotEnumerable = () => {};
+    const originalNotEnumerable = () => {};
+    const obj: Record<string, unknown> = {
+      enumerable: originalEnumerable,
+    };
+    Object.defineProperty(obj, 'notEnumerable', {
+      writable: true,
+      configurable: true,
+      enumerable: false,
+      value: originalNotEnumerable,
+    });
+    wrapMethod(obj, 'notEnumerable', wrappedNotEnumerable, false);
+    wrapMethod(obj, 'enumerable', wrappedEnumerable);
+    // does not change enumerability
+    expect(Object.keys(obj)).toStrictEqual(['enumerable']);
+    expect(obj.notEnumerable).toBe(wrappedNotEnumerable);
+    expect((obj.notEnumerable as WrappedFunction).__sentry_original__).toBe(originalNotEnumerable);
+    expect(obj.enumerable).toBe(wrappedEnumerable);
+    expect((obj.enumerable as WrappedFunction).__sentry_original__).toBe(originalEnumerable);
+  });
+
+  it('throws if misused', () => {
+    const wrapped = () => {};
+    const original = () => {};
+    const obj = {
+      get m() {
+        return original;
+      },
+    };
+    wrapMethod(obj, 'm', wrapped);
+    expect(() => {
+      //@ts-expect-error verify type checking prevents this mistake
+      wrapMethod(obj, 'foo', wrapped);
+    }).toThrowError('Cannot wrap method: foo is not a function');
+    expect(() => {
+      wrapMethod(obj, 'm', wrapped);
+    }).toThrowError('Attempting to wrap method m multiple times');
+  });
+});