22745360142

Committed 06 Mar 2026 01:50AM UTC coverage: 95.287% (+0.9%) from 94.396%

Build # 22745360142

Build Type

Pull #28

github

Committed by

web-flow

Commit Message

Merge 15ef847b4 into 828e39903

Pull Request Pull Request #28: TypeScript and event dispatching pipeline refactoring

Run Details

428 of 528 branches covered (81.06%)

1043 of 1091 new or added lines in 65 files covered. (95.6%)

3 existing lines in 2 files now uncovered.

1294 of 1358 relevant lines covered (95.29%)

31.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.83

/src/utils/setupOneTimeEmitterSubscription.ts

import type { IEvent, ILogger, IObservable } from '../interfaces/index.ts';
import { assertStringArray, assertFunction, assertObservable } from './assert.ts';

/**
 * Create one-time eventEmitter subscription for one or multiple events that match a filter
 *
 * @param {IObservable} emitter
 * @param {string[]} messageTypes Array of event type to subscribe to
 * @param {function(IEvent):any} [handler] Optional handler to execute for a first event received
 * @param {function(IEvent):boolean} [filter] Optional filter to apply before executing a handler
 * @param {ILogger} logger
 * @return {Promise<IEvent>} Resolves to first event that passes filter
 */
export function setupOneTimeEmitterSubscription(
        emitter: IObservable,
        messageTypes: string[],
        filter?: (e: IEvent) => boolean,
        handler?: (e: IEvent) => void,
        logger?: ILogger
): Promise<IEvent> {
        assertObservable(emitter, 'emitter');
        assertStringArray(messageTypes, 'messageTypes');
        if (handler)
                assertFunction(handler, 'handler');
        if (filter)
                assertFunction(filter, 'filter');

        return new Promise(resolve => {

                // handler will be invoked only once,
                // even if multiple events have been emitted before subscription was destroyed
                // https://nodejs.org/api/events.html#events_emitter_removelistener_eventname_listener
                let handled = false;

                function filteredHandler(event: IEvent) {
                        if (filter && !filter(event))
                                return;
                        if (handled)
                                return;
                        handled = true;

                        for (const messageType of messageTypes)
                                emitter.off(messageType, filteredHandler);

                        logger?.debug(`'${event.type}' received, one-time subscription to '${messageTypes.join(',')}' removed`);

                        if (handler)
                                handler(event);

                        resolve(event);
                }

                for (const messageType of messageTypes)
                        emitter.on(messageType, filteredHandler);

                logger?.debug(`set up one-time ${filter ? 'filtered subscription' : 'subscription'} to '${messageTypes.join(',')}'`);
        });
}

1	import type { IEvent, ILogger, IObservable } from '../interfaces/index.ts';
2	import { assertStringArray, assertFunction, assertObservable } from './assert.ts';	23✔
3
4	/**
5	* Create one-time eventEmitter subscription for one or multiple events that match a filter
6	*
7	* @param {IObservable} emitter
8	* @param {string[]} messageTypes Array of event type to subscribe to
9	* @param {function(IEvent):any} [handler] Optional handler to execute for a first event received
10	* @param {function(IEvent):boolean} [filter] Optional filter to apply before executing a handler
11	* @param {ILogger} logger
12	* @return {Promise<IEvent>} Resolves to first event that passes filter
13	*/
14	export function setupOneTimeEmitterSubscription(	23✔
15	emitter: IObservable,
16	messageTypes: string[],
17	filter?: (e: IEvent) => boolean,
18	handler?: (e: IEvent) => void,
19	logger?: ILogger
20	): Promise<IEvent> {
21	assertObservable(emitter, 'emitter');	7✔
22	assertStringArray(messageTypes, 'messageTypes');	7✔
23	if (handler)	7✔
24	assertFunction(handler, 'handler');	3✔
25	if (filter)	7✔
26	assertFunction(filter, 'filter');	3✔
27
28	return new Promise(resolve => {	6✔
29
30	// handler will be invoked only once,
31	// even if multiple events have been emitted before subscription was destroyed
32	// https://nodejs.org/api/events.html#events_emitter_removelistener_eventname_listener
33	let handled = false;	6✔
34
35	function filteredHandler(event: IEvent) {
36	if (filter && !filter(event))	7✔
37	return;	2✔
38	if (handled)	5!
NEW 39	return;	×
40	handled = true;	5✔
41
42	for (const messageType of messageTypes)	5✔
43	emitter.off(messageType, filteredHandler);	5✔
44
45	logger?.debug(`'${event.type}' received, one-time subscription to '${messageTypes.join(',')}' removed`);	5✔
46
47	if (handler)	5✔
48	handler(event);	3✔
49
50	resolve(event);	5✔
51	}
52
53	for (const messageType of messageTypes)	6✔
54	emitter.on(messageType, filteredHandler);	6✔
55
56	logger?.debug(`set up one-time ${filter ? 'filtered subscription' : 'subscription'} to '${messageTypes.join(',')}'`);	6!
57	});
58	}

snatalenko / node-cqrs / 22745360142

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous