fixup! fixup! feat(core, node): portable Express integration

Author: isaacs

packages/core/src/utils/object.ts

@@ -96,21 +96,6 @@ export function wrapMethod<O extends {}, T extends string & keyof O>(obj: O, fie
   addNonEnumerableProperty(obj, field, wrapped);
 }
 
-/**
- * Unwrap a previously wrapped method on an object by name
- */
-export function unwrapMethod<O extends {}, T extends string & keyof O>(obj: O, field: T): void {
-  const wrapped = obj[field];
-  if (typeof wrapped !== 'function') {
-    throw new Error(`Cannot unwrap method: ${field} is not a function`);
-  }
-  const original = getOriginalFunction(wrapped);
-  if (!original) {
-    throw new Error(`Method ${field} is not wrapped, and cannot be unwrapped`);
-  }
-  addNonEnumerableProperty(obj, field, original);
-}
-
 /**
  * This extracts the original function if available.  See
  * `markFunctionWrapped` for more information.

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

@@ -11,7 +11,6 @@ import {
   fill,
   markFunctionWrapped,
   objectify,
-  unwrapMethod,
   wrapMethod,
 } from '../../../src/utils/object';
 import { testOnlyIfNodeVersionAtLeast } from '../../testutils';
@@ -458,16 +457,14 @@ describe('markFunctionWrapped', () => {
   });
 });
 
-describe('unwrapMethod, wrapMethod', () => {
+describe('wrapMethod', () => {
   it('can wrap a method on an object and unwrap it later', () => {
     const wrapped = () => {};
     const original = () => {};
     const obj = { m: original };
     wrapMethod(obj, 'm', wrapped);
     expect(obj.m).toBe(wrapped);
     expect((obj.m as WrappedFunction).__sentry_original__).toBe(original);
-    unwrapMethod(obj, 'm');
-    expect(obj.m).toBe(original);
   });
 
   it('throws if misused', () => {
@@ -479,16 +476,8 @@ describe('unwrapMethod, wrapMethod', () => {
       //@ts-expect-error verify type checking prevents this mistake
       wrapMethod(obj, 'foo', wrapped);
     }).toThrowError('Cannot wrap method: foo is not a function');
-    expect(() => {
-      //@ts-expect-error verify type checking prevents this mistake
-      unwrapMethod(obj, 'foo');
-    }).toThrowError('Cannot unwrap method: foo is not a function');
     expect(() => {
       wrapMethod(obj, 'm', wrapped);
     }).toThrowError('Attempting to wrap method m multiple times');
-    unwrapMethod(obj, 'm');
-    expect(() => {
-      unwrapMethod(obj, 'm');
-    }).toThrowError('Method m is not wrapped, and cannot be unwrapped');
   });
 });