Events refactor

src/app/events/listeners/UserCreatedListener.ts

@@ -0,0 +1,15 @@
+import BaseEventListener from "@src/core/domains/events/base/BaseEventListener";
+
+export class UserCreatedListener extends BaseEventListener {
+
+    /**
+     * Optional method to execute before the subscribers are dispatched.
+     */
+    async execute(): Promise<void> {
+
+        // const payload = this.getPayload<IUserData>();
+
+        // Handle logic
+    }
+
+}

src/app/events/subscribers/UserCreatedSubscriber.ts

@@ -0,0 +1,28 @@
+import BaseEvent from "@src/core/domains/events/base/BaseEvent";
+import SyncDriver from "@src/core/domains/events/drivers/SyncDriver";
+
+export default class UserCreatedSubscriber extends BaseEvent {
+
+    static readonly eventName = 'UserCreatedSubscriber';
+
+    protected namespace: string = 'auth';
+
+    constructor(payload) {
+        super(payload, SyncDriver);
+    }
+
+    getName(): string {
+        return UserCreatedSubscriber.eventName;
+    }
+
+    getQueueName(): string {
+        return 'default';
+    }
+
+    async execute(): Promise<void> {
+        // const payload = this.getPayload<IUserData>();
+
+        // Handle logic
+    }
+
+}

src/app/observers/UserObserver.ts

@@ -1,3 +1,4 @@
+import { UserCreatedListener } from "@src/app/events/listeners/UserCreatedListener";
 import { IUserData } from "@src/app/models/auth/User";
 import hashPassword from "@src/core/domains/auth/utils/hashPassword";
 import Observer from "@src/core/domains/observer/services/Observer";
@@ -22,6 +23,16 @@ export default class UserObserver extends Observer<IUserData> {
         return data
     }
 
+    /**
+     * Called after the User model has been created.
+     * @param data The User data that has been created.
+     * @returns The processed User data.
+     */
+    async created(data: IUserData): Promise<IUserData> {
+        await App.container('events').dispatch(new UserCreatedListener(data))
+        return data
+    }
+
     /**
      * Updates the roles of the user based on the groups they belong to.
      * Retrieves the roles associated with each group the user belongs to from the permissions configuration.

src/config/events.ts

@@ -1,71 +1,69 @@
-import { ExampleListener } from "@src/app/events/listeners/ExampleListener";
-import QueueDriver, { QueueDriverOptions } from "@src/core/domains/events/drivers/QueueDriver";
-import SynchronousDriver from "@src/core/domains/events/drivers/SynchronousDriver";
-import { IEventDrivers, ISubscribers } from "@src/core/domains/events/interfaces/IEventConfig";
+import { UserCreatedListener } from "@src/app/events/listeners/UserCreatedListener";
+import UserCreatedSubscriber from "@src/app/events/subscribers/UserCreatedSubscriber";
+import QueueableDriver, { TQueueDriverOptions } from "@src/core/domains/events/drivers/QueableDriver";
+import SyncDriver from "@src/core/domains/events/drivers/SyncDriver";
+import { IEventConfig } from "@src/core/domains/events/interfaces/config/IEventConfig";
+import FailedWorkerModel from "@src/core/domains/events/models/FailedWorkerModel";
 import WorkerModel from "@src/core/domains/events/models/WorkerModel";
-import DriverOptions from "@src/core/domains/events/services/QueueDriverOptions";
+import EventService from "@src/core/domains/events/services/EventService";
 
 /**
- * Default Event Driver Configuration
- * 
- * This setting determines which event driver will be used by default when no specific
- * driver is defined for an event. The value is read from the APP_EVENT_DRIVER
- * environment variable, falling back to 'sync' if not set.
- * 
- * Options:
- * - 'sync': Events are processed immediately.
- * - 'queue': Events are queued for background processing.
+ * Event Drivers Constants
  */
-export const defaultEventDriver: string = process.env.APP_EVENT_DRIVER ?? 'sync';
+export const EVENT_DRIVERS = {
+    SYNC: EventService.getDriverName(SyncDriver),
+    QUEABLE: EventService.getDriverName(QueueableDriver)
+}
 
-/**
- * Event Drivers Configuration
- * 
- * This object defines the available event drivers and their configurations.
- * Each driver can have its own set of options to customize its behavior.
- * 
- * Structure:
- * {
- *   [driverName: string]: {
- *     driver: Class extending IEventDriver,
- *     options?: DriverOptions object
- *   }
- * }
- */
-export const eventDrivers: IEventDrivers = {
-    // Synchronous Driver: Processes events immediately
-    sync: {
-        driver: SynchronousDriver
-    },
-    // Queue Driver: Saves events for background processing
-    queue: {
-        driver: QueueDriver,
-        options: new DriverOptions<QueueDriverOptions>({
-            queueName: 'default',     // Name of the queue
-            retries: 3,               // Number of retry attempts for failed events
-            failedCollection: 'failedWorkers',  // Collection to store failed events
-            runAfterSeconds: 10,      // Delay before processing queued events
-            workerModelCtor: WorkerModel  // Constructor for the Worker model
+export const eventConfig: IEventConfig = {
+
+    /**
+     * Default Event Driver
+     */
+    defaultDriver: SyncDriver,
+
+    /**
+     * Event Drivers Configuration
+     * 
+     * This object defines the available event drivers and their configurations.
+     * Each driver can have its own set of options to customize its behavior.
+     */
+    drivers: {
+
+        // Synchronous Driver: Processes events immediately
+        [EVENT_DRIVERS.SYNC]: EventService.createConfigDriver(SyncDriver, {}),
+
+        // Queue Driver: Saves events for background processing
+        [EVENT_DRIVERS.QUEABLE]: EventService.createConfigDriver<TQueueDriverOptions>(QueueableDriver, {
+            queueName: 'default',                    // Name of the queue
+            retries: 3,                              // Number of retry attempts for failed events
+            runAfterSeconds: 10,                     // Delay before processing queued events
+            workerModelCtor: WorkerModel,            // Constructor for the Worker model
+            failedWorkerModelCtor: FailedWorkerModel,
         })
-    }
-} as const;
+
+    },
+
+    /**
+     * Register Events
+     */
+    events: EventService.createConfigEvents([
+
+    ]),
+
+    /**
+     * Event Listeners Configuration
+     * 
+     * These are automatically registered with the event service
+     *  and do not need to be added to 'events' array.
+     */
+    listeners: EventService.createConfigListeners([
+        {
+            listener: UserCreatedListener,
+            subscribers: [
+                UserCreatedSubscriber
+            ]
+        }
+    ]),
 
-/**
- * Event Subscribers Configuration
- * 
- * This object maps event names to arrays of listener classes. When an event
- * is dispatched, all listeners registered for that event will be executed.
- * 
- * Structure:
- * {
- *   [eventName: string]: Array<ListenerClass>
- * }
- * 
- * Example usage:
- * When an 'OnExample' event is dispatched, the ExampleListener will be triggered.
- */
-export const eventSubscribers: ISubscribers = {
-    'OnExample': [
-        ExampleListener
-    ]   
 }

src/core/base/BaseCastable.ts

@@ -0,0 +1,8 @@
+import HasCastableConcern from "@src/core/concerns/HasCastableConcern";
+import { IHasCastableConcern } from "@src/core/interfaces/concerns/IHasCastableConcern";
+import { ICtor } from "@src/core/interfaces/ICtor";
+import compose from "@src/core/util/compose";
+
+const BaseCastable: ICtor<IHasCastableConcern> = compose(class {}, HasCastableConcern)
+
+export default BaseCastable

src/core/concerns/HasAttributesConcern.ts

@@ -5,6 +5,16 @@ import { IHasAttributes, IHasAttributesSetAttributeOptions as SetAttributeOption
 import { ICtor } from "@src/core/interfaces/ICtor";
 import IModelAttributes from "@src/core/interfaces/IModelData";
 
+/**
+ * Concern that adds the ability to set and retrieve attributes from a model, and to broadcast when attributes change.
+ * The concern is a mixin and can be applied to any class that implements the IBroadcaster interface.
+ * The concern adds the following methods to the class: setAttribute, getAttribute, getAttributes, getOriginal, isDirty, and getDirty.
+ * The concern also adds a constructor that subscribes to the SetAttributeBroadcastEvent and calls the onSetAttributeEvent method when the event is triggered.
+ * The concern is generic and can be used with any type of model attributes.
+ * @template Attributes The type of the model's attributes.
+ * @param {ICtor<IBroadcaster>} Base The base class to extend with the concern.
+ * @returns {ICtor<IBroadcaster & IHasAttributes>} A class that extends the base class with the concern.
+ */
 const HasAttributesConcern = <Attributes extends IModelAttributes>(Base: ICtor<IBroadcaster>) => {
     return class HasAttributes extends Base implements IHasAttributes {