test: coverage and cleanup unused type

Author: logaretm

src/__testUtils__/fakeDiagnosticsChannel.ts

@@ -14,6 +14,7 @@ export type Listener = (message: unknown) => void;
 export class FakeChannel implements MinimalChannel {
   listeners: Array<Listener> = [];
 
+  /* c8 ignore next 3 */
   get [Symbol.toStringTag]() {
     return 'FakeChannel';
   }
@@ -55,7 +56,7 @@ export class FakeChannel implements MinimalChannel {
 
 /**
  * Structurally-faithful `MinimalTracingChannel` implementation mirroring
- * Node's `TracingChannel.traceSync` / `tracePromise` lifecycle
+ * Node's `TracingChannel.traceSync` lifecycle.
  */
 export class FakeTracingChannel implements MinimalTracingChannel {
   start: FakeChannel = new FakeChannel();
@@ -64,6 +65,7 @@ export class FakeTracingChannel implements MinimalTracingChannel {
   asyncEnd: FakeChannel = new FakeChannel();
   error: FakeChannel = new FakeChannel();
 
+  /* c8 ignore next 3 */
   get [Symbol.toStringTag]() {
     return 'FakeTracingChannel';
   }
@@ -95,55 +97,18 @@ export class FakeTracingChannel implements MinimalTracingChannel {
         throw err;
       }
       // Node's real traceSync sets `ctx.result` before publishing `end`, so
-      // subscribers can inspect `isPromise(ctx.result)` inside their `end`
-      // handler to decide whether the operation is complete or async events
-      // will follow. Match that semantic here.
+      // subscribers can inspect `ctx.result` inside their `end` handler.
       (ctx as { result: unknown }).result = result;
       this.end.publish(ctx);
       return result;
     });
   }
-
-  tracePromise<T>(
-    fn: (...args: Array<unknown>) => Promise<T>,
-    ctx: object,
-    thisArg?: unknown,
-    ...args: Array<unknown>
-  ): Promise<T> {
-    return this.start.runStores(ctx, () => {
-      let promise: Promise<T>;
-      try {
-        promise = fn.apply(thisArg as object, args);
-      } catch (err) {
-        (ctx as { error: unknown }).error = err;
-        this.error.publish(ctx);
-        this.end.publish(ctx);
-        throw err;
-      }
-      this.end.publish(ctx);
-      this.asyncStart.publish(ctx);
-      return promise
-        .then(
-          (result) => {
-            (ctx as { result: unknown }).result = result;
-            return result;
-          },
-          (err: unknown) => {
-            (ctx as { error: unknown }).error = err;
-            this.error.publish(ctx);
-            throw err;
-          },
-        )
-        .finally(() => {
-          this.asyncEnd.publish(ctx);
-        });
-    });
-  }
 }
 
 export class FakeDc implements MinimalDiagnosticsChannel {
   private cache = new Map<string, FakeTracingChannel>();
 
+  /* c8 ignore next 3 */
   get [Symbol.toStringTag]() {
     return 'FakeDc';
   }

src/__tests__/diagnostics-test.ts

@@ -29,9 +29,6 @@ function fakeTracingChannel(name: string): MinimalTracingChannel {
     asyncEnd: noop,
     error: noop,
     traceSync: <T>(fn: (...args: Array<unknown>) => T): T => fn(),
-    tracePromise: <T>(
-      fn: (...args: Array<unknown>) => Promise<T>,
-    ): Promise<T> => fn(),
   };
   return channel;
 }

src/diagnostics.ts

@@ -49,13 +49,6 @@ export interface MinimalTracingChannel {
     thisArg?: unknown,
     ...args: Array<unknown>
   ) => T;
-
-  tracePromise: <T>(
-    fn: (...args: Array<unknown>) => Promise<T>,
-    ctx: object,
-    thisArg?: unknown,
-    ...args: Array<unknown>
-  ) => Promise<T>;
 }
 
 /**

src/execution/__tests__/resolve-diagnostics-test.ts

@@ -25,6 +25,7 @@ const schema = buildSchema(`
     sync: String
     async: String
     fail: String
+    asyncFail: String
     plain: String
     nested: Nested
   }
@@ -39,6 +40,7 @@ const rootValue = {
   fail: () => {
     throw new Error('boom');
   },
+  asyncFail: () => Promise.reject(new Error('async-boom')),
   // no `plain` resolver, default property-access is used.
   plain: 'plain-value',
   nested: { leaf: 'leaf-value' },
@@ -98,6 +100,29 @@ describe('resolve diagnostics channel', () => {
     expect(kinds).to.deep.equal(['start', 'error', 'end']);
   });
 
+  it('emits full async lifecycle with error when a resolver rejects', async () => {
+    active = collectEvents(resolveChannel);
+
+    await execute({
+      schema,
+      document: parse('{ asyncFail }'),
+      rootValue,
+    });
+
+    const kinds = active.events.map((e) => e.kind);
+    expect(kinds).to.deep.equal([
+      'start',
+      'end',
+      'asyncStart',
+      'error',
+      'asyncEnd',
+    ]);
+    const errorEvent = active.events.find((e) => e.kind === 'error');
+    expect((errorEvent?.ctx as { error?: Error }).error?.message).to.equal(
+      'async-boom',
+    );
+  });
+
   it('reports isTrivialResolver based on field.resolve presence', () => {
     const trivialSchema = new GraphQLSchema({
       query: new GraphQLObjectType({

src/index.ts

@@ -34,7 +34,7 @@ export { enableDevMode, isDevModeEnabled } from './devMode.js';
 
 // Register a `node:diagnostics_channel`-compatible module to enable
 // tracing channel emission from parse, validate, execute, subscribe,
-// and resolver lifecycles.
+// and resolver lifecycle events.
 export { enableDiagnosticsChannel } from './diagnostics.js';
 export type {
   MinimalChannel,