Replace Promise.withResolvers with createPromiseResolver

Introduced a new utility function `createPromiseResolver` to handle promise creation alongside external resolvers. Updated all references of `Promise.withResolvers` in the codebase and tests to use the new utility, ensuring compatibility and maintaining consistency.

Author: cod1k

packages/cloudflare/src/flush.ts

@@ -1,4 +1,5 @@
 import type { ExecutionContext } from '@cloudflare/workers-types';
+import { createPromiseResolver } from './utils/makePromiseResolver';
 
 type FlushLock = {
   readonly ready: Promise<void>;
@@ -33,7 +34,7 @@ export function makeFlushLock(context: ExecutionContext): FlushLock {
   }
   let pending = 0;
   const originalWaitUntil = context.waitUntil.bind(context) as typeof context.waitUntil;
-  const { promise, resolve } = Promise.withResolvers();
+  const { promise, resolve } = createPromiseResolver();
   const hijackedWaitUntil: typeof originalWaitUntil = promise => {
     pending++;
     return originalWaitUntil(

packages/cloudflare/src/types.d.ts

@@ -0,0 +1,26 @@
+type PromiseWithResolvers<T, E = unknown> = {
+  readonly promise: Promise<T>;
+  readonly resolve: (value?: T | PromiseLike<T>) => void;
+  readonly reject: (reason?: E) => void;
+};
+/**
+ * Creates an object containing a promise, along with its corresponding resolve and reject functions.
+ *
+ * This method provides a convenient way to create a promise and access its resolvers externally.
+ *
+ * @template T - The type of the resolved value of the promise.
+ * @template E - The type of the rejected value of the promise. Defaults to `unknown`.
+ * @return {PromiseWithResolvers<T, E>} An object containing the promise and its resolve and reject functions.
+ */
+export function createPromiseResolver<T, E = unknown>(): PromiseWithResolvers<T, E> {
+  if ('withResolvers' in Promise && typeof Promise.withResolvers === 'function') {
+    return Promise.withResolvers();
+  }
+  let resolve;
+  let reject;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject } as unknown as PromiseWithResolvers<T, E>;
+}

packages/cloudflare/src/utils/makePromiseResolver.ts

@@ -3,6 +3,7 @@ import * as SentryCore from '@sentry/core';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { instrumentDurableObjectWithSentry } from '../src';
 import { isInstrumented } from '../src/instrument';
+import { createPromiseResolver } from '../src/utils/makePromiseResolver';
 
 describe('instrumentDurableObjectWithSentry', () => {
   afterEach(() => {
@@ -124,7 +125,7 @@ describe('instrumentDurableObjectWithSentry', () => {
   it('flush performs after all waitUntil promises are finished', async () => {
     const flush = vi.spyOn(SentryCore.Client.prototype, 'flush');
     const waitUntil = vi.fn();
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = createPromiseResolver();
     process.nextTick(resolve);
     const testClass = vi.fn(context => ({
       fetch: () => {

packages/cloudflare/test/durableobject.test.ts

@@ -1,6 +1,7 @@
 import { type ExecutionContext } from '@cloudflare/workers-types';
 import { describe, expect, it, vi } from 'vitest';
 import { makeFlushLock } from '../src/flush';
+import { createPromiseResolver } from '../src/utils/makePromiseResolver';
 
 describe('Flush buffer test', () => {
   const mockExecutionContext: ExecutionContext = {
@@ -18,7 +19,7 @@ describe('Flush buffer test', () => {
     );
   });
   it('should flush buffer only after all waitUntil were finished', async () => {
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = createPromiseResolver();
     const lock = makeFlushLock(mockExecutionContext);
     mockExecutionContext.waitUntil(promise);
     process.nextTick(resolve);

packages/cloudflare/test/flush.test.ts

@@ -14,6 +14,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { CloudflareClient } from '../src/client';
 import { withSentry } from '../src/handler';
 import { markAsInstrumented } from '../src/instrument';
+import { createPromiseResolver } from '../src/utils/makePromiseResolver';
 
 // Custom type for hono-like apps (cloudflare handlers) that include errorHandler and onError
 type HonoLikeApp<Env = unknown, QueueHandlerMessage = unknown, CfHostMetadata = unknown> = ExportedHandler<
@@ -38,7 +39,7 @@ function makeWaitUntilAndTask<
   },
 >(): T {
   const waitUntil = vi.fn();
-  const { promise, resolve } = Promise.withResolvers();
+  const { promise, resolve } = createPromiseResolver();
   const resolver = vi.fn().mockImplementation(resolve).mockName('waitUntil.ready');
   Object.defineProperties(waitUntil, {
     ready: {

packages/cloudflare/test/handler.test.ts

@@ -9,6 +9,7 @@ import { setAsyncLocalStorageAsyncContextStrategy } from '../src/async';
 import type { CloudflareOptions } from '../src/client';
 import { CloudflareClient } from '../src/client';
 import { wrapRequestHandler } from '../src/request';
+import { createPromiseResolver } from '../src/utils/makePromiseResolver';
 
 const MOCK_OPTIONS: CloudflareOptions = {
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
@@ -72,7 +73,7 @@ describe('withSentry', () => {
       waitUntil,
     } as unknown as ExecutionContext;
 
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve } = createPromiseResolver();
     const resolved = vi.fn(() => resolve());
     process.nextTick(resolved);