fix(syncpromise): use the right make fn

Author: JonasBa

packages/browser/src/transports/fetch.ts

@@ -1,5 +1,5 @@
 import { Event, Response, SentryRequest, Session, TransportOptions } from '@sentry/types';
-import { makeSyncPromise, SentryError, supportsReferrerPolicy } from '@sentry/utils';
+import { makePlatformPromise, SentryError, supportsReferrerPolicy } from '@sentry/utils';
 
 import { BaseTransport } from './base';
 import { FetchImpl, getNativeFetchImplementation } from './utils';
@@ -52,7 +52,7 @@ export class FetchTransport extends BaseTransport {
 
     return this._buffer
       .add(() =>
-        makeSyncPromise<Response>((resolve, reject) => {
+        makePlatformPromise<Response>((resolve, reject) => {
           void this._fetch(sentryRequest.url, options)
             .then(response => {
               const headers = {

packages/browser/src/transports/xhr.ts

@@ -1,5 +1,5 @@
 import { Event, Response, SentryRequest, Session } from '@sentry/types';
-import { makeSyncPromise, SentryError } from '@sentry/utils';
+import { makePlatformPromise, SentryError } from '@sentry/utils';
 
 import { BaseTransport } from './base';
 
@@ -25,7 +25,7 @@ export class XHRTransport extends BaseTransport {
 
     return this._buffer
       .add(() =>
-        makeSyncPromise<Response>((resolve, reject) => {
+        makePlatformPromise<Response>((resolve, reject) => {
           const request = new XMLHttpRequest();
 
           request.onreadystatechange = (): void => {

packages/core/test/lib/base.test.ts

@@ -1,6 +1,6 @@
 import { Hub, Scope, Session } from '@sentry/hub';
 import { Event, Span, Transport } from '@sentry/types';
-import { logger, SentryError, makeSyncPromise } from '@sentry/utils';
+import { logger, makePlatformPromise,SentryError } from '@sentry/utils';
 
 import * as integrationModule from '../../src/integration';
 import { TestBackend } from '../mocks/backend';
@@ -1230,7 +1230,7 @@ describe('BaseClient', () => {
       const delay = 300;
       const spy = jest.spyOn(TestBackend.instance!, 'eventFromMessage');
       spy.mockImplementationOnce((message, level) =>
-        makeSyncPromise(resolve => {
+        makePlatformPromise(resolve => {
           setTimeout(() => resolve({ message, level }), 150);
         }),
       );

packages/core/test/mocks/transport.ts

@@ -1,8 +1,8 @@
 import { Event, Response, Transport } from '@sentry/types';
-import { makePromiseBuffer, PromiseBuffer, makeSyncPromise } from '@sentry/utils';
+import { makePlatformPromise,makePromiseBuffer, PromiseBuffer } from '@sentry/utils';
 
 async function sleep(delay: number): Promise<void> {
-  return makeSyncPromise(resolve => setTimeout(resolve, delay));
+  return makePlatformPromise(resolve => setTimeout(resolve, delay));
 }
 
 export class FakeTransport implements Transport {
@@ -16,7 +16,7 @@ export class FakeTransport implements Transport {
   public sendEvent(_event: Event): PromiseLike<Response> {
     this.sendCalled += 1;
     return this._buffer.add(() =>
-      makeSyncPromise(async res => {
+      makePlatformPromise(async res => {
         await sleep(this.delay);
         this.sentCount += 1;
         res({ status: 'success' });

packages/hub/src/scope.ts

@@ -18,7 +18,7 @@ import {
   Transaction,
   User,
 } from '@sentry/types';
-import { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, makeSyncPromise } from '@sentry/utils';
+import { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, makePlatformPromise } from '@sentry/utils';
 
 import { Session } from './session';
 
@@ -459,7 +459,7 @@ export class Scope implements ScopeInterface {
     hint?: EventHint,
     index: number = 0,
   ): PromiseLike<Event | null> {
-    return makeSyncPromise<Event | null>((resolve, reject) => {
+    return makePlatformPromise<Event | null>((resolve, reject) => {
       const processor = processors[index];
       if (event === null || typeof processor !== 'function') {
         resolve(event);

packages/node/src/backend.ts

@@ -7,7 +7,7 @@ import {
   extractExceptionKeysForMessage,
   isError,
   isPlainObject,
-  makeSyncPromise,
+  makePlatformPromise,
   normalizeToSize,
 } from '@sentry/utils';
 
@@ -55,7 +55,7 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
       mechanism.synthetic = true;
     }
 
-    return makeSyncPromise<Event>((resolve, reject) =>
+    return makePlatformPromise<Event>((resolve, reject) =>
       parseError(ex as Error, this._options)
         .then(event => {
           addExceptionTypeValue(event, undefined, undefined);
@@ -80,7 +80,7 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
       message,
     };
 
-    return makeSyncPromise<Event>(resolve => {
+    return makePlatformPromise<Event>(resolve => {
       if (this._options.attachStacktrace && hint && hint.syntheticException) {
         const stack = hint.syntheticException ? extractStackFromError(hint.syntheticException) : [];
         void parseStack(stack, this._options)

packages/utils/test/is.test.ts

@@ -1,8 +1,17 @@
 import { resolvedSyncPromise } from '../dist';
 import { isDOMError, isDOMException, isError, isErrorEvent, isInstanceOf, isPrimitive, isThenable } from '../src/is';
 import { supportsDOMError, supportsDOMException, supportsErrorEvent } from '../src/supports';
-import { makeSyncPromise, makePlatformResolvedPromise } from '../src/syncpromise';
-import { SentryError } from '../src/error';
+import { makePlatformResolvedPromise,makeSyncPromise } from '../src/syncpromise';
+
+class SentryError extends Error {
+  public name: string;
+
+  public constructor(public message: string) {
+    super(message);
+    this.name = new.target.prototype.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
 
 if (supportsDOMError()) {
   describe('isDOMError()', () => {

packages/utils/test/promisebuffer.test.ts

@@ -1,11 +1,11 @@
 import { makePromiseBuffer } from '../src/promisebuffer';
-import { makeSyncPromise } from '../src/syncpromise';
+import { makePlatformPromise } from '../src/syncpromise';
 
 describe('PromiseBuffer', () => {
   describe('add()', () => {
     test('no limit', () => {
       const buffer = makePromiseBuffer();
-      const p = jest.fn(() => makeSyncPromise(resolve => setTimeout(resolve)));
+      const p = jest.fn(() => makePlatformPromise(resolve => setTimeout(resolve)));
       void buffer.add(p);
       expect(buffer.$.length).toEqual(1);
     });
@@ -14,10 +14,10 @@ describe('PromiseBuffer', () => {
       const buffer = makePromiseBuffer(1);
       let task1;
       const producer1 = jest.fn(() => {
-        task1 = makeSyncPromise(resolve => setTimeout(resolve));
+        task1 = makePlatformPromise(resolve => setTimeout(resolve));
         return task1;
       });
-      const producer2 = jest.fn(() => makeSyncPromise(resolve => setTimeout(resolve)));
+      const producer2 = jest.fn(() => makePlatformPromise(resolve => setTimeout(resolve)));
       expect(buffer.add(producer1)).toEqual(task1);
       void expect(buffer.add(producer2)).rejects.toThrowError();
       expect(buffer.$.length).toEqual(1);
@@ -30,7 +30,7 @@ describe('PromiseBuffer', () => {
     test('without timeout', async () => {
       const buffer = makePromiseBuffer();
       for (let i = 0; i < 5; i++) {
-        void buffer.add(() => makeSyncPromise(resolve => setTimeout(resolve)));
+        void buffer.add(() => makePlatformPromise(resolve => setTimeout(resolve)));
       }
       expect(buffer.$.length).toEqual(5);
       const result = await buffer.drain();
@@ -41,7 +41,7 @@ describe('PromiseBuffer', () => {
     test('with timeout', async () => {
       const buffer = makePromiseBuffer();
       for (let i = 0; i < 5; i++) {
-        void buffer.add(() => makeSyncPromise(resolve => setTimeout(resolve, 100)));
+        void buffer.add(() => makePlatformPromise(resolve => setTimeout(resolve, 100)));
       }
       expect(buffer.$.length).toEqual(5);
       const result = await buffer.drain(50);
@@ -59,7 +59,7 @@ describe('PromiseBuffer', () => {
 
   test('resolved promises should not show up in buffer length', async () => {
     const buffer = makePromiseBuffer();
-    const producer = () => makeSyncPromise(resolve => setTimeout(resolve));
+    const producer = () => makePlatformPromise(resolve => setTimeout(resolve));
     const task = buffer.add(producer);
     expect(buffer.$.length).toEqual(1);
     await task;
@@ -68,7 +68,7 @@ describe('PromiseBuffer', () => {
 
   test('rejected promises should not show up in buffer length', async () => {
     const buffer = makePromiseBuffer();
-    const producer = () => makeSyncPromise((_, reject) => setTimeout(reject));
+    const producer = () => makePlatformPromise((_, reject) => setTimeout(reject));
     const task = buffer.add(producer);
     expect(buffer.$.length).toEqual(1);
     try {
@@ -81,7 +81,7 @@ describe('PromiseBuffer', () => {
 
   test('resolved task should give an access to the return value', async () => {
     const buffer = makePromiseBuffer<string>();
-    const producer = () => makeSyncPromise<string>(resolve => setTimeout(() => resolve('test')));
+    const producer = () => makePlatformPromise<string>(resolve => setTimeout(() => resolve('test')));
     const task = buffer.add(producer);
     const result = await task;
     expect(result).toEqual('test');
@@ -90,7 +90,7 @@ describe('PromiseBuffer', () => {
   test('rejected task should give an access to the return value', async () => {
     expect.assertions(1);
     const buffer = makePromiseBuffer<string>();
-    const producer = () => makeSyncPromise<string>((_, reject) => setTimeout(() => reject(new Error('whoops'))));
+    const producer = () => makePlatformPromise<string>((_, reject) => setTimeout(() => reject(new Error('whoops'))));
     const task = buffer.add(producer);
     try {
       await task;

packages/utils/test/syncpromise.test.ts

@@ -1,4 +1,9 @@
-import { makeSyncPromise, SyncPromise } from '../src/syncpromise';
+import {
+  makePlatformRejectedPromise,
+  makePlatformResolvedPromise,
+  makeSyncPromise,
+  SyncPromise,
+} from '../src/syncpromise';
 
 describe('SyncPromise', () => {
   test('simple', () => {