14431053423

Committed 13 Apr 2025 03:59PM UTC coverage: 83.069% (+0.7%) from 82.347%

Build # 14431053423

Build Type

push

github

Committed by

snatalenko

Commit Message

1.0.0-rc.8

Run Details

490 of 782 branches covered (62.66%)

996 of 1199 relevant lines covered (83.07%)

21.49 hits per line

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

76.0

/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(	38✔
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)	4!
21	throw new TypeError('emitter argument must be an Object');	×
22	if (!Array.isArray(messageTypes) \|\| messageTypes.some(m => !m \|\| typeof m !== 'string'))	4✔
23	throw new TypeError('messageTypes argument must be an Array of non-empty Strings');	×
24	if (handler && typeof handler !== 'function')	4!
25	throw new TypeError('handler argument, when specified, must be a Function');	×
26	if (filter && typeof filter !== 'function')	4!
27	throw new TypeError('filter argument, when specified, must be a Function');	×
28
29	return new Promise(resolve => {	4✔
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;	4✔
35
36	function filteredHandler(event: IEvent) {
37	if (filter && !filter(event))	4!
38	return;	×
39	if (handled)	4!
40	return;	×
41	handled = true;	4✔
42
43	for (const messageType of messageTypes)	4✔
44	emitter.off(messageType, filteredHandler);	4✔
45
46	logger?.debug(`'${event.type}' received, one-time subscription to '${messageTypes.join(',')}' removed`);	4✔
47
48	if (handler)	4✔
49	handler(event);	4✔
50
51	resolve(event);	4✔
52	}
53
54	for (const messageType of messageTypes)	4✔
55	emitter.on(messageType, filteredHandler);	4✔
56
57	logger?.debug(`set up one-time ${filter ? 'filtered subscription' : 'subscription'} to '${messageTypes.join(',')}'`);	4!
58	});
59	}

snatalenko / node-cqrs / 14431053423

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