@adonisjs/events 7.1.3 → 7.2.0

package/build/adonis-typings/events.d.ts

@@ -40,11 +40,87 @@ declare module '@ioc:Adonis/Core/Event' {
         clearListeners(event?: string): any;
         listenerCount(event?: string): number;
     }
+    /**
+     * Fake emitter to be used for finding and asserting
+     * faked events
+     */
+    export interface FakeEmitterContract {
+        /**
+         * Returns all the emitted events
+         */
+        all(): {
+            name: string;
+            data: any;
+        }[];
+        /**
+         * Find if the event exists
+         */
+        exists<K extends keyof EventsList>(event: K): boolean;
+        exists(event: string): boolean;
+        exists<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
+            [K in keyof Events]: {
+                name: K;
+                data: Events[K];
+            };
+        }[keyof Events]) => boolean): boolean;
+        /**
+         * Find an event
+         */
+        find<K extends keyof EventsList>(event: K): {
+            name: K;
+            data: DataForEvent<K>;
+        } | null;
+        find(event: string): {
+            name: string;
+            data: any;
+        };
+        find<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
+            [K in keyof Events]: {
+                name: K;
+                data: Events[K];
+            };
+        }[keyof Events]) => boolean): {
+            [K in keyof Events]: {
+                name: K;
+                data: Events[K];
+            };
+        }[keyof Events] | null;
+        /**
+         * Find multiple events
+         */
+        filter<K extends keyof EventsList>(event: K): {
+            name: K;
+            data: DataForEvent<K>;
+        }[];
+        filter(event: string): {
+            name: string;
+            data: any;
+        }[];
+        filter<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
+            [K in keyof Events]: {
+                name: K;
+                data: Events[K];
+            };
+        }[keyof Events]) => boolean): {
+            [K in keyof Events]: {
+                name: K;
+                data: Events[K];
+            };
+        }[keyof Events][];
+        /**
+         * Get number of events emitted
+         */
+        size(): number;
+    }
     /**
      * Shape of Event emitter
      */
     export interface EmitterContract {
         transport: EmitterTransportContract;
+        /**
+         * Fake the upcoming events
+         */
+        fake<K extends keyof EventsList>(events?: K[] | string[]): FakeEmitterContract;
         /**
          * Define a custom error handler
          */

package/build/src/Emitter/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference path="../../adonis-typings/events.d.ts" />
 import { ApplicationContract } from '@ioc:Adonis/Core/Application';
 import { AnyHandler, EventsList, TrapHandler, EventHandler, DataForEvent, ErrorHandler, TrapAllHandler, EmitterContract, EmitterTransportContract } from '@ioc:Adonis/Core/Event';
+import { FakeEmitter } from '../FakeEmitter';
 /**
  * Emitter class exposes the API for async event emitter built on top of
  * Emittery. It also exposes an API to pre-define the Typescript types
@@ -9,10 +10,21 @@ import { AnyHandler, EventsList, TrapHandler, EventHandler, DataForEvent, ErrorH
 export declare class Emitter implements EmitterContract {
     transport: EmitterTransportContract;
     private iocResolver?;
+    /**
+     * Error handler to report emitter errors
+     */
+    private errorHandler?;
+    /**
+     * Deprecated properties to manage trapping events
+     */
     private trappingEvents;
     private traps;
     private trapAllHandler?;
-    private errorHandler?;
+    /**
+     * Fakes
+     */
+    private eventsToFake;
+    private fakeEmitter?;
     constructor(app?: ApplicationContract);
     /**
      * Returns reference to the IoC resolver. Do not call this method until
@@ -85,7 +97,12 @@ export declare class Emitter implements EmitterContract {
      */
     trapAll(handler: TrapAllHandler): this;
     /**
-     * Restore trap
+     * Fake event emitter to collect events in-memory vs
+     * emitting them
+     */
+    fake(events?: any[]): FakeEmitter;
+    /**
+     * Restore trap and fake
      */
     restore(): this;
 }

package/build/src/Emitter/index.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
 /// <reference path="../../adonis-typings/events.ts" />
 const emittery_1 = __importDefault(require("emittery"));
+const FakeEmitter_1 = require("../FakeEmitter");
 const IocResolver_1 = require("../IocResolver");
 /**
  * Emitter class exposes the API for async event emitter built on top of
@@ -23,8 +24,15 @@ const IocResolver_1 = require("../IocResolver");
 class Emitter {
     constructor(app) {
         this.transport = new emittery_1.default();
+        /**
+         * Deprecated properties to manage trapping events
+         */
         this.trappingEvents = false;
         this.traps = new Map();
+        /**
+         * Fakes
+         */
+        this.eventsToFake = new Set();
         if (app) {
             this.iocResolver = new IocResolver_1.IocResolver(app);
         }
@@ -87,21 +95,30 @@ class Emitter {
      */
     async emit(event, data) {
         try {
+            let shouldEmitEvent = true;
+            /**
+             * Register event with the fake emitter
+             */
+            if (this.fakeEmitter && (this.eventsToFake.has('*') || this.eventsToFake.has(event))) {
+                shouldEmitEvent = false;
+                this.fakeEmitter.events.push({ name: event, data });
+            }
             if (this.trappingEvents) {
                 /**
                  * Give preference to the handler for a specific event
                  */
                 if (this.traps.has(event)) {
-                    return await this.traps.get(event)(data);
+                    shouldEmitEvent = false;
+                    await this.traps.get(event)(data);
                 }
-                /**
-                 * Invoke catch all (if defined)
-                 */
-                if (this.trapAllHandler) {
-                    return await this.trapAllHandler(event, data);
+                else if (this.trapAllHandler) {
+                    shouldEmitEvent = false;
+                    await this.trapAllHandler(event, data);
                 }
             }
-            return await this.transport.emit(event, data);
+            if (shouldEmitEvent) {
+                return await this.transport.emit(event, data);
+            }
         }
         catch (error) {
             if (this.errorHandler) {
@@ -183,6 +200,7 @@ class Emitter {
      * Trap event instead of emitting it
      */
     trap(event, handler) {
+        process.emitWarning('DeprecationWarning', '"Event.trap" is deprecated. Instead use "Event.fake" method');
         this.trappingEvents = true;
         this.traps.set(event, handler);
         return this;
@@ -191,17 +209,42 @@ class Emitter {
      * Trap all events instead of emitting them
      */
     trapAll(handler) {
+        process.emitWarning('DeprecationWarning', '"Event.trapAll" is deprecated. Instead use "Event.fake" method');
         this.trappingEvents = true;
         this.trapAllHandler = handler;
         return this;
     }
     /**
-     * Restore trap
+     * Fake event emitter to collect events in-memory vs
+     * emitting them
+     */
+    fake(events) {
+        this.fakeEmitter = this.fakeEmitter || new FakeEmitter_1.FakeEmitter();
+        /**
+         * If no events have been mentioned, then fake
+         * all the events
+         */
+        if (!events) {
+            this.eventsToFake.add('*');
+            return this.fakeEmitter;
+        }
+        /**
+         * Only track event names when wildcard is not added
+         */
+        if (!this.eventsToFake.has('*')) {
+            events.forEach((event) => this.eventsToFake.add(event));
+        }
+        return this.fakeEmitter;
+    }
+    /**
+     * Restore trap and fake
      */
     restore() {
         this.trappingEvents = false;
-        this.traps.clear();
         this.trapAllHandler = undefined;
+        this.fakeEmitter = undefined;
+        this.traps.clear();
+        this.eventsToFake.clear();
         return this;
     }
 }

package/build/src/FakeEmitter/index.d.ts

@@ -0,0 +1,43 @@
+import { FakeEmitterContract } from '@ioc:Adonis/Core/Event';
+/**
+ * Fake emitter to be used for finding and asserting
+ * faked events
+ */
+export declare class FakeEmitter implements FakeEmitterContract {
+    events: {
+        name: string;
+        data: any;
+    }[];
+    /**
+     * Get all the emitted events
+     */
+    all(): {
+        name: string;
+        data: any;
+    }[];
+    /**
+     * Returns the size of captured events
+     */
+    size(): number;
+    /**
+     * Find if the event has emitted
+     */
+    exists(eventOrCallback: string | ((event: {
+        name: string;
+        data: any;
+    }) => boolean)): boolean;
+    /**
+     * Get selected events
+     */
+    filter(eventOrCallback: string | ((event: {
+        name: string;
+        data: any;
+    }) => boolean)): any[];
+    /**
+     * Find a specific event
+     */
+    find(eventOrCallback: string | ((event: {
+        name: string;
+        data: any;
+    }) => boolean)): any;
+}

package/build/src/FakeEmitter/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeEmitter = void 0;
+/**
+ * Fake emitter to be used for finding and asserting
+ * faked events
+ */
+class FakeEmitter {
+    constructor() {
+        this.events = [];
+    }
+    /**
+     * Get all the emitted events
+     */
+    all() {
+        return this.events;
+    }
+    /**
+     * Returns the size of captured events
+     */
+    size() {
+        return this.events.length;
+    }
+    /**
+     * Find if the event has emitted
+     */
+    exists(eventOrCallback) {
+        return !!this.find(eventOrCallback);
+    }
+    /**
+     * Get selected events
+     */
+    filter(eventOrCallback) {
+        if (typeof eventOrCallback === 'function') {
+            return this.events.filter(eventOrCallback);
+        }
+        return this.events.filter((event) => event.name === eventOrCallback);
+    }
+    /**
+     * Find a specific event
+     */
+    find(eventOrCallback) {
+        if (typeof eventOrCallback === 'function') {
+            return this.events.find(eventOrCallback);
+        }
+        return this.events.find((event) => event.name === eventOrCallback);
+    }
+}
+exports.FakeEmitter = FakeEmitter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/events",
-  "version": "7.1.3",
+  "version": "7.2.0",
   "description": "Event emitter with asynchronous events",
   "main": "build/providers/EventProvider.js",
   "files": [
@@ -13,8 +13,8 @@
   "scripts": {
     "mrm": "mrm --preset=@adonisjs/mrm-preset",
     "pretest": "npm run lint",
-    "test": "node .bin/test.js",
-    "clean": "del build",
+    "test": "node -r @adonisjs/require-ts/build/register bin/test.ts",
+    "clean": "del-cli build",
     "compile": "npm run lint && npm run clean && tsc",
     "build": "npm run compile",
     "commit": "git-cz",
@@ -35,6 +35,10 @@
     "@adonisjs/application": "^5.1.5",
     "@adonisjs/mrm-preset": "^5.0.2",
     "@adonisjs/require-ts": "^2.0.7",
+    "@japa/assert": "^1.2.3",
+    "@japa/run-failed-tests": "^1.0.3",
+    "@japa/runner": "^2.0.6",
+    "@japa/spec-reporter": "^1.1.7",
     "@poppinss/dev-utils": "^2.0.1",
     "@types/node": "^17.0.8",
     "commitizen": "^4.2.4",
@@ -46,8 +50,7 @@
     "eslint-plugin-prettier": "^4.0.0",
     "github-label-sync": "^2.0.1",
     "husky": "^7.0.1",
-    "japa": "^4.0.0",
-    "mrm": "^3.0.2",
+    "mrm": "^4.0.0",
     "np": "^7.5.0",
     "prettier": "^2.3.2",
     "typescript": "^4.3.5"