feat(core): Update withScope to return callback return value

To align this with OpenTelemetry and make some things possible that are currently not easily doable without `pushScope` / `popScope`.

Author: mydea

packages/core/src/exports.ts

@@ -163,8 +163,8 @@ export function setUser(user: User | null): ReturnType<Hub['setUser']> {
  *
  * @param callback that will be enclosed into push/popScope.
  */
-export function withScope(callback: (scope: Scope) => void): ReturnType<Hub['withScope']> {
-  getCurrentHub().withScope(callback);
+export function withScope<T>(callback: (scope: Scope) => T): T {
+  return getCurrentHub().withScope(callback);
 }
 
 /**

packages/core/src/hub.ts

@@ -161,10 +161,10 @@ export class Hub implements HubInterface {
   /**
    * @inheritDoc
    */
-  public withScope(callback: (scope: Scope) => void): void {
+  public withScope<T>(callback: (scope: Scope) => T): T {
     const scope = this.pushScope();
     try {
-      callback(scope);
+      return callback(scope);
     } finally {
       this.popScope();
     }

packages/core/test/lib/exports.test.ts

@@ -0,0 +1,53 @@
+import { Hub, Scope, makeMain, withScope, getCurrentScope } from '../../src';
+import { TestClient, getDefaultTestClientOptions } from '../mocks/client';
+
+function getTestClient(): TestClient {
+  return new TestClient(
+    getDefaultTestClientOptions({
+      dsn: 'https://username@domain/123',
+    }),
+  );
+}
+
+describe('withScope', () => {
+  beforeEach(() => {
+    const client = getTestClient();
+    const hub = new Hub(client);
+    makeMain(hub);
+  });
+
+  it('works without a return value', () => {
+    const scope1 = getCurrentScope();
+    expect(scope1).toBeInstanceOf(Scope);
+
+    scope1.setTag('foo', 'bar');
+
+    const res = withScope(scope => {
+      expect(scope).toBeInstanceOf(Scope);
+      expect(scope).not.toBe(scope1);
+      expect(scope['_tags']).toEqual({ foo: 'bar' });
+
+      expect(getCurrentScope()).toBe(scope);
+    });
+
+    expect(getCurrentScope()).toBe(scope1);
+    expect(res).toBe(undefined);
+  });
+
+  it('works with a return value', () => {
+    const res = withScope(scope => {
+      return 'foo';
+    });
+
+    expect(res).toBe('foo');
+  });
+
+  it('works with an async function',async  () => {
+    const res = withScope(async scope => {
+      return 'foo';
+    });
+
+    expect(res).toBeInstanceOf(Promise);
+    expect(await res).toBe('foo')
+  });
+});

packages/types/src/hub.ts

@@ -65,7 +65,7 @@ export interface Hub {
    *
    * @param callback that will be enclosed into push/popScope.
    */
-  withScope(callback: (scope: Scope) => void): void;
+  withScope<T>(callback: (scope: Scope) => T): T;
 
   /** Returns the client of the top stack. */
   getClient(): Client | undefined;