chore(deps): update jest monorepo to v30 (major) (#2605)

* chore(deps): update jest monorepo to v30

* ..

* Lets go

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Arda TANRIKULU <[email protected]>

Author: renovate[bot]

package.json

@@ -34,7 +34,7 @@
     "@ianvs/prettier-plugin-sort-imports": "4.4.2",
     "@theguild/prettier-config": "2.0.7",
     "@types/benchmark": "2.1.5",
-    "@types/jest": "29.5.14",
+    "@types/jest": "30.0.0",
     "@types/k6": "1.0.2",
     "@types/node": "22.15.32",
     "@typescript-eslint/eslint-plugin": "8.35.0",
@@ -53,7 +53,7 @@
     "eslint-plugin-unicorn": "59.0.1",
     "globby": "14.1.0",
     "husky": "9.1.7",
-    "jest": "29.7.0",
+    "jest": "30.0.2",
     "lint-staged": "16.1.2",
     "prettier": "3.6.0",
     "prettier-plugin-pkg": "0.21.1",

packages/core/src/utils.ts

@@ -109,74 +109,96 @@ export function finalAsyncIterator<TInput>(
   source: AsyncIterable<TInput>,
   onFinal: () => void,
 ): AsyncGenerator<TInput> {
-  const iterator = source[Symbol.asyncIterator]();
+  let iterator: AsyncIterator<TInput>;
+  function ensureIterator() {
+    if (!iterator) {
+      iterator = source[Symbol.asyncIterator]();
+    }
+    return iterator;
+  }
   let isDone = false;
-  const stream: AsyncGenerator<TInput> = {
+  return {
     [Symbol.asyncIterator]() {
-      return stream;
+      return this;
     },
     next() {
-      return iterator.next().then(result => {
-        if (result.done && isDone === false) {
-          isDone = true;
-          onFinal();
-        }
-        return result;
-      });
+      return ensureIterator()
+        .next()
+        .then(result => {
+          if (result.done && isDone === false) {
+            isDone = true;
+            onFinal();
+          }
+          return result;
+        });
     },
     return() {
-      const promise = iterator.return?.();
+      const promise = ensureIterator().return?.();
       if (isDone === false) {
         isDone = true;
         onFinal();
       }
       return promise || fakePromise({ done: true, value: undefined });
     },
     throw(error: unknown) {
-      const promise = iterator.throw?.();
+      const promise = ensureIterator().throw?.();
       if (promise) {
         return promise;
       }
       // if the source has no throw method we just re-throw error
       // usually throw is not called anyways
       throw error;
     },
-  };
-
-  return stream;
+    [Symbol.asyncDispose || Symbol.for('Symbol.asyncDispose')]() {
+      // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+      // is properly cleaned up when the subscription is disposed.
+      return fakePromise();
+    },
+  } as AsyncGenerator<TInput>;
 }
 
 export function errorAsyncIterator<TInput>(
   source: AsyncIterable<TInput>,
   onError: (err: unknown) => void,
 ): AsyncGenerator<TInput> {
-  const iterator = source[Symbol.asyncIterator]();
-  const stream: AsyncGenerator<TInput> = {
+  let iterator: AsyncIterator<TInput>;
+  function ensureIterator() {
+    if (!iterator) {
+      iterator = source[Symbol.asyncIterator]();
+    }
+    return iterator;
+  }
+  return {
     [Symbol.asyncIterator]() {
-      return stream;
+      return this;
     },
     next() {
-      return iterator.next().catch(error => {
-        onError(error);
-        return { done: true, value: undefined };
-      });
+      return ensureIterator()
+        .next()
+        .catch(error => {
+          onError(error);
+          return { done: true, value: undefined };
+        });
     },
     return() {
-      const promise = iterator.return?.();
+      const promise = ensureIterator().return?.();
       return promise || fakePromise({ done: true, value: undefined });
     },
     throw(error: unknown) {
-      const promise = iterator.throw?.();
+      const promise = ensureIterator().throw?.();
       if (promise) {
         return promise;
       }
       // if the source has no throw method we just re-throw error
       // usually throw is not called anyways
       throw error;
     },
-  };
-
-  return stream;
+    [Symbol.asyncDispose || Symbol.for('Symbol.asyncDispose')]() {
+      // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+      // is properly cleaned up when the subscription is disposed.
+      return fakePromise();
+    },
+  } as AsyncGenerator<TInput>;
 }
 
 export { mapMaybePromise, isPromise } from '@whatwg-node/promise-helpers';

packages/core/test/execute.spec.ts

@@ -8,6 +8,7 @@ import {
 } from '@envelop/testing';
 import { OnExecuteDoneHookResult, OnSubscribeResultResult } from '@envelop/types';
 import { makeExecutableSchema } from '@graphql-tools/schema';
+import { fakePromise } from '@whatwg-node/promise-helpers';
 import { query, schema } from './common.js';
 
 type Deferred<T = void> = {
@@ -324,6 +325,11 @@ describe('execute', () => {
       async throw() {
         throw new Error('Noop.');
       },
+      [Symbol.asyncDispose]() {
+        // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+        // is properly cleaned up when the subscription is disposed.
+        return fakePromise();
+      },
     });
 
     const teskit = createTestkit(
@@ -380,24 +386,30 @@ describe('execute', () => {
       const delayNextDeferred = createDeferred();
       let isReturnCalled = false;
 
-      const streamExecuteFn = (): AsyncGenerator => ({
-        [Symbol.asyncIterator]() {
-          return this;
-        },
-        async next() {
-          return delayNextDeferred.promise.then(() => ({
-            value: { data: { alphabet: 'a' } },
-            done: false,
-          }));
-        },
-        async return() {
-          isReturnCalled = true;
-          return { done: true, value: undefined };
-        },
-        async throw() {
-          throw new Error('Noop.');
-        },
-      });
+      const streamExecuteFn = () =>
+        ({
+          [Symbol.asyncIterator]() {
+            return this;
+          },
+          async next() {
+            return delayNextDeferred.promise.then(() => ({
+              value: { data: { alphabet: 'a' } },
+              done: false,
+            }));
+          },
+          async return() {
+            isReturnCalled = true;
+            return { done: true, value: undefined };
+          },
+          async throw() {
+            throw new Error('Noop.');
+          },
+          [Symbol.asyncDispose]() {
+            // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+            // is properly cleaned up when the subscription is disposed.
+            return fakePromise();
+          },
+        }) as AsyncGenerator;
 
       const teskit = createTestkit(
         [
@@ -462,7 +474,7 @@ describe('execute', () => {
     expect.assertions(2);
     let isReturnCalled = false;
     const values = ['a', 'b', 'c', 'd'];
-    const source: AsyncGenerator = {
+    const source = {
       [Symbol.asyncIterator]() {
         return this;
       },
@@ -480,7 +492,12 @@ describe('execute', () => {
       async throw() {
         throw new Error('Noop.');
       },
-    };
+      [Symbol.asyncDispose]() {
+        // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+        // is properly cleaned up when the subscription is disposed.
+        return fakePromise();
+      },
+    } as AsyncGenerator;
 
     const schema = makeExecutableSchema({
       typeDefs: /* GraphQL */ `
@@ -575,7 +592,7 @@ it.each([
     const delayNextDeferred = createDeferred();
     let isReturnCalled = false;
 
-    const source: AsyncGenerator = {
+    const source = {
       [Symbol.asyncIterator]() {
         return this;
       },
@@ -592,7 +609,12 @@ it.each([
       async throw() {
         throw new Error('Noop.');
       },
-    };
+      [Symbol.asyncDispose]() {
+        // This is a no-op, but we need to implement it to ensure that the AsyncGenerator
+        // is properly cleaned up when the subscription is disposed.
+        return fakePromise();
+      },
+    } as AsyncGenerator;
 
     const schema = makeExecutableSchema({
       typeDefs: /* GraphQL */ `

packages/core/test/plugins/use-error-handler.spec.ts

@@ -134,7 +134,7 @@ describe('useErrorHandler', () => {
 
     expect(mockHandler).toHaveBeenCalledWith(
       expect.objectContaining({
-        errors: expect.objectContaining([testError]),
+        errors: expect.arrayContaining([testError]),
         phase: 'execution',
       }),
     );

packages/plugins/fragment-arguments/package.json

@@ -60,7 +60,7 @@
     "@types/common-tags": "1.8.4",
     "common-tags": "1.8.2",
     "graphql": "16.8.1",
-    "jest-diff": "29.7.0",
+    "jest-diff": "30.0.2",
     "oneline": "2.0.0",
     "typescript": "5.8.3"
   },

packages/plugins/on-resolve/test/use-on-resolve.spec.ts

@@ -25,8 +25,8 @@ describe('useOnResolve', () => {
 
     await testkit.execute('{ test: value1, test1: value2 }');
 
-    expect(onResolveFn).toBeCalledTimes(2);
-    expect(onResolveDoneFn).toBeCalledTimes(2);
+    expect(onResolveFn).toHaveBeenCalledTimes(2);
+    expect(onResolveDoneFn).toHaveBeenCalledTimes(2);
 
     let i = 0;
     for (const field of ['value1', 'value2']) {
@@ -55,8 +55,8 @@ describe('useOnResolve', () => {
 
     await testkit.execute('{ __schema{ ... on __Schema{ queryType { name } } } }');
 
-    expect(onResolveFn).toBeCalledTimes(2);
-    expect(onResolveDoneFn).toBeCalledTimes(2);
+    expect(onResolveFn).toHaveBeenCalledTimes(2);
+    expect(onResolveDoneFn).toHaveBeenCalledTimes(2);
 
     let i = 0;
     for (const field of ['queryType', 'name']) {
@@ -81,8 +81,8 @@ describe('useOnResolve', () => {
 
     await testkit.execute('{ __schema{ ... on __Schema{ queryType { name } } } }');
 
-    expect(onResolveFn).toBeCalledTimes(0);
-    expect(onResolveDoneFn).toBeCalledTimes(0);
+    expect(onResolveFn).toHaveBeenCalledTimes(0);
+    expect(onResolveDoneFn).toHaveBeenCalledTimes(0);
   });
 
   it('should replace the result using the after hook', async () => {
@@ -122,7 +122,7 @@ describe('useOnResolve', () => {
 
     const result = await testkit.execute('{ value1 }');
     // Expect two calls, not four.
-    expect(afterResolve).toBeCalledTimes(2);
+    expect(afterResolve).toHaveBeenCalledTimes(2);
 
     assertSingleExecutionValue(result);
     expect(result.data?.value1).toBe('value2');