14002510880

Committed 21 Mar 2025 11:15PM UTC coverage: 82.347% (-12.1%) from 94.436%

Build # 14002510880

Build Type

push

github

Committed by

snatalenko

Commit Message

1.0.0-rc.6

Run Details

450 of 731 branches covered (61.56%)

877 of 1065 relevant lines covered (82.35%)

21.41 hits per line

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

82.61

/src/utils/setupOneTimeEmitterSubscription.ts

import { IEvent, ILogger, IObservable } from "../interfaces";

/**
 * 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> {
        if (typeof emitter !== 'object' || !emitter)
                throw new TypeError('emitter argument must be an Object');
        if (!Array.isArray(messageTypes) || messageTypes.some(m => !m || typeof m !== 'string'))
                throw new TypeError('messageTypes argument must be an Array of non-empty Strings');
        if (handler && typeof handler !== 'function')
                throw new TypeError('handler argument, when specified, must be a Function');
        if (filter && typeof filter !== 'function')
                throw new TypeError('filter argument, when specified, must be a Function');

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

snatalenko / node-cqrs / 14002510880

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