feat(debug): metadataRegistryEvents emitter

e2e/reporters/recorder.js

@@ -16,6 +16,7 @@ class E2eRecorderReporter extends JestMetadataReporter {
   _events = {};
   _single = false;
   _bail = false;
+  _countOfMetadataObjects = 0;
 
   constructor(globalConfig) {
     super(globalConfig);
@@ -44,6 +45,7 @@ class E2eRecorderReporter extends JestMetadataReporter {
   };
 
   #subscribeToMetadataEvents = () => {
+    debugUtils.metadataRegistryEvents.on('register_metadata', () => this._countOfMetadataObjects++);
     if (PRESET.includes('no-env')) return;
     debugUtils.events.on('*', this.#pushEvent);
   };
@@ -83,11 +85,9 @@ class E2eRecorderReporter extends JestMetadataReporter {
       fs.mkdirSync(path.dirname(fixturePath), { recursive: true });
       fs.writeFileSync(fixturePath, contents + '\n');
     }
-  }
-}
 
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+    console.log('Total metadata objects:', this._countOfMetadataObjects);
+  }
 }
 
 module.exports = E2eRecorderReporter;

package-e2e/test.cjs

@@ -10,8 +10,9 @@ assert(typeof $Assign === 'function', 'jest-metadata should export $Assign funct
 assert(typeof $Defaults === 'function', 'jest-metadata should export $Defaults function as a named export');
 assert(typeof $Unshift === 'function', 'jest-metadata should export $Unshift function as a named export');
 
-const { events } = require('jest-metadata/debug');
+const { events, metadataRegistryEvents } = require('jest-metadata/debug');
 assert(typeof events === 'object', 'jest-metadata/debug should export `events` object');
+assert(typeof metadataRegistryEvents === 'object', 'jest-metadata/debug should export `metadataRegistryEvents` object');
 
 const environmentListener = require('jest-metadata/environment-listener');
 assert(typeof environmentListener === 'function', 'jest-metadata/environment-listener should export a class as its default export');

package-e2e/test.mjs

@@ -1,6 +1,6 @@
 import assert from 'assert';
 import { $Set, $Push, $Merge, $Assign, $Defaults, $Unshift, state, metadata } from 'jest-metadata';
-import { events } from 'jest-metadata/debug';
+import { events, metadataRegistryEvents } from 'jest-metadata/debug';
 import JsdomTestEnvironment from 'jest-metadata/environment-jsdom';
 import NodeTestEnvironment from 'jest-metadata/environment-node';
 import environmentListener from 'jest-metadata/environment-listener';
@@ -16,6 +16,7 @@ assert(typeof $Defaults === 'function', 'jest-metadata should export `$Defaults`
 assert(typeof $Unshift === 'function', 'jest-metadata should export `$Unshift` function as a named export');
 
 assert(typeof events === 'object', 'jest-metadata/debug should export `events` object');
+assert(typeof metadataRegistryEvents === 'object', 'jest-metadata/debug should export `metadataRegistryEvents` object');
 
 assert(typeof environmentListener === 'function', 'jest-metadata/environment-listener should export a function as its default export');
 

package-e2e/test.ts

@@ -1,5 +1,5 @@
 import { $Set, $Push, $Merge, $Assign, $Defaults, $Unshift, state, metadata } from 'jest-metadata';
-import { events } from 'jest-metadata/debug';
+import { events, metadataRegistryEvents } from 'jest-metadata/debug';
 import type { GlobalMetadata, Metadata } from 'jest-metadata';
 import JestMetadataReporter, { query, JestMetadataReporter as JestMetadataReporterNamed } from 'jest-metadata/reporter';
 import JsdomTestEnvironment from 'jest-metadata/environment-jsdom';
@@ -32,6 +32,34 @@ $Defaults('path', { key: 'value' });
 $Defaults(['path'], { key: 'value' });
 
 assertType<object>(events);
+events.on('setup', (e) => assertType<string>(e.type));
+events.on('add_hook', (e) => assertType<string>(e.type));
+events.on('add_test', (e) => assertType<string>(e.type));
+events.on('finish_describe_definition', (e) => assertType<string>(e.type));
+events.on('hook_failure', (e) => assertType<string>(e.type));
+events.on('hook_start', (e) => assertType<string>(e.type));
+events.on('hook_success', (e) => assertType<string>(e.type));
+events.on('run_describe_finish', (e) => assertType<string>(e.type));
+events.on('run_describe_start', (e) => assertType<string>(e.type));
+events.on('run_finish', (e) => assertType<string>(e.type));
+events.on('run_start', (e) => assertType<string>(e.type));
+events.on('write_metadata', (e) => assertType<string>(e.type));
+events.on('start_describe_definition', (e) => assertType<string>(e.type));
+events.on('test_done', (e) => assertType<string>(e.type));
+events.on('add_test_file', (e) => assertType<string>(e.type));
+events.on('test_fn_failure', (e) => assertType<string>(e.type));
+events.on('test_fn_start', (e) => assertType<string>(e.type));
+events.on('test_fn_success', (e) => assertType<string>(e.type));
+events.on('test_retry', (e) => assertType<string>(e.type));
+events.on('test_skip', (e) => assertType<string>(e.type));
+events.on('test_start', (e) => assertType<string>(e.type));
+events.on('test_started', (e) => assertType<string>(e.type));
+events.on('test_todo', (e) => assertType<string>(e.type));
+
+metadataRegistryEvents.on('register_metadata', (e) => {
+  assertType<'register_metadata'>(e.type);
+  assertType<unknown>(e.metadata.get());
+});
 
 assertType<Function>(JestMetadataReporter, JestMetadataReporterNamed);
 assertType<object>(JestMetadataReporter.query, query);

src/debug.ts

@@ -9,3 +9,5 @@ export function isFallback() {
 }
 
 export const events = realm.events;
+
+export const metadataRegistryEvents = realm.metadataRegistry.events;

src/metadata/registry/GlobalMetadataRegistry.ts

@@ -1,13 +1,25 @@
+import type { ReadonlyEmitter } from '../../types';
+import { SerialEmitter } from '../../utils';
 import type { AggregatedIdentifier } from '../ids';
 import type { Metadata } from '../types';
 
 import type { FileMetadataRegistry } from './FileMetadataRegistry';
 import { ScopedMetadataRegistry } from './ScopedMetadataRegistry';
 
+export type MetadataRegisterEvent = {
+  type: 'register_metadata';
+  metadata: Metadata;
+};
+
 export class GlobalMetadataRegistry implements FileMetadataRegistry<AggregatedIdentifier> {
+  private readonly emitter = new SerialEmitter<MetadataRegisterEvent>('globalMetadataRegistry');
   private readonly scopes: Record<string, ScopedMetadataRegistry> = {};
   private readonly root = new ScopedMetadataRegistry('globalMetadata');
 
+  public get events(): ReadonlyEmitter<MetadataRegisterEvent> {
+    return this.emitter;
+  }
+
   public get(scopedId: AggregatedIdentifier): Metadata {
     const { testFilePath, identifier } = scopedId;
     const registry = testFilePath ? this.scopes[testFilePath] : this.root;
@@ -20,6 +32,8 @@ export class GlobalMetadataRegistry implements FileMetadataRegistry<AggregatedId
   }
 
   public register(scopedId: AggregatedIdentifier, metadata: Metadata): void {
+    this.emitter.emit({ type: 'register_metadata', metadata });
+
     const { testFilePath, identifier } = scopedId;
     if (!testFilePath) {
       return this.root.register(identifier, metadata);