fix(): rename notify to notification

.commitlintrc.json

@@ -9,7 +9,7 @@
     "type-enum": [
       2,
       "always",
-      ["build", "chore", "ci", "docs", "feat", "fix", "perf", "refactor", "style", "test"]
+      ["build", "chore", "ci", "docs", "feat", "fix", "perf", "refactor", "style", "test", "revert"]
     ]
   }
 }

README.md

@@ -24,10 +24,10 @@ $ npm i @sinuos/nestjs-notification
 ### Declare module
 
 ```typescript
-import { NestjsNotifyModule } from '@sinuos/nestjs-notify.module';
+import { NestjsNotificationModule } from '@sinuos/nestjs-notify.module';
 
 @Module({
-  imports: [NestjsNotifyModule.register()],
+  imports: [NestjsNotificationModule.register()],
 })
 export class AppModule {}
 ```
@@ -68,11 +68,11 @@ export class InvoicPaidNotification implements NestJsNotify {
 
 ```typescript
 import { Injectable } from '@nestjs/common';
-import { NestjsNotifyService } from '@sinuos/nestjs-notify.service';
+import { NestjsNotificationService } from '@sinuos/nestjs-notify.service';
 
 @Injectable()
 export class AppService {
-  constructor(private notify: NestjsNotifyService) {}
+  constructor(private notify: NestjsNotificationService) {}
 
   notify() {
     const notification = new InvoicePaidNotification();

lib/constants/index.ts

@@ -1 +1 @@
-export * from './nestjs-notify-provider.constant';
+export * from './nestjs-notification-provider.constant';

lib/constants/nestjs-notification-provider.constant.ts

@@ -0,0 +1 @@
+export const NESTJS_NOTIFICATION_OPTIONS = 'NESTJS_NOTIFICATION_OPTIONS';

lib/index.ts

@@ -1,3 +1,3 @@
 export * from './interfaces';
-export * from './nestjs-notify.module';
-export * from './nestjs-notify.service';
+export * from './nestjs-notification.module';
+export * from './nestjs-notification.service';

lib/interfaces/index.ts

@@ -1,3 +1,3 @@
-export * from './nestjs-notify.interface';
-export * from './nestjs-notify-module.interface';
-export * from './nestjs-notify-channel.interface';
+export * from './nestjs-notification.interface';
+export * from './nestjs-notification-module.interface';
+export * from './nestjs-notification-channel.interface';

lib/interfaces/nestjs-notification-channel.interface.ts

@@ -0,0 +1,14 @@
+import { NestJsNotification } from './nestjs-notification.interface';
+
+/**
+ * @interface INestjsNotificationChannel
+ * @property send()
+ */
+export interface INestjsNotificationChannel {
+  /**
+   * Send the given notification
+   * @param {NestJsNotification} notification
+   * @return Promise<any>
+   */
+  send(notification: NestJsNotification): Promise<any>;
+}

lib/interfaces/nestjs-notification-module.interface.ts

@@ -0,0 +1,35 @@
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+
+/**
+ * @interface NestjsNotificationModuleOptionsFactory
+ * @property createNestjsNotificationOptions()
+ */
+export interface NestjsNotificationModuleOptionsFactory {
+  createNestjsNotificationOptions():
+    | Promise<NestjsNotificationModuleOptions>
+    | NestjsNotificationModuleOptions;
+}
+
+/**
+ * @interface NestjsNotificationModuleAsyncOptions
+ * @extends {Pick<ModuleMetadata, 'imports'>}
+ * @property useExisting
+ * @property useClass
+ * @property useFactory
+ * @property inject
+ * @property extraProviders
+ */
+export interface NestjsNotificationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  useExisting?: Type<NestjsNotificationModuleOptionsFactory>;
+  useClass?: Type<NestjsNotificationModuleOptionsFactory>;
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<NestjsNotificationModuleOptions> | NestjsNotificationModuleOptions;
+  inject?: any[];
+  extraProviders?: Provider[];
+}
+
+/**
+ * @interface NestjsNotificationModuleOptions
+ */
+export type NestjsNotificationModuleOptions = null;

lib/interfaces/nestjs-notify.interface.ts → lib/interfaces/nestjs-notification.interface.ts

@@ -1,17 +1,17 @@
 import { Type } from '@nestjs/common';
-import { INestjsNotifyChannel } from './nestjs-notify-channel.interface';
+import { INestjsNotificationChannel } from './nestjs-notification-channel.interface';
 
 /**
- * @interface NestJsNotify
+ * @interface NestJsNotification
  * @property sendToChannels()
  * @property toPayload?()
  */
-export interface NestJsNotify {
+export interface NestJsNotification {
   /**
    * Get the channels the notification should broadcast on.
-   * @returns {Type<INestjsNotifyChannel>[]} array
+   * @returns {Type<INestjsNotificationChannel>[]} array
    */
-  sendToChannels(): Type<INestjsNotifyChannel>[];
+  sendToChannels(): Type<INestjsNotificationChannel>[];
 
   /**
    * Get the json representation of the notification.

lib/nestjs-notification.module.ts

@@ -0,0 +1,112 @@
+import { DynamicModule, Module, Provider, ValueProvider } from '@nestjs/common';
+import { NestjsNotificationService } from './nestjs-notification.service';
+import {
+  NestjsNotificationModuleAsyncOptions,
+  NestjsNotificationModuleOptions,
+  NestjsNotificationModuleOptionsFactory,
+} from './interfaces';
+import { NESTJS_NOTIFICATION_OPTIONS } from './constants';
+
+@Module({})
+export class NestjsNotificationModule {
+  /**
+   * Register module
+   * @static
+   * @param {NestjsNotificationModuleOptions} options
+   * @return DynamicModule
+   */
+  static register(options: NestjsNotificationModuleOptions): DynamicModule {
+    const notifyProvider: ValueProvider = {
+      provide: NESTJS_NOTIFICATION_OPTIONS,
+      useValue: options,
+    };
+
+    return {
+      module: NestjsNotificationModule,
+      providers: [NestjsNotificationService, notifyProvider],
+      exports: [NestjsNotificationService, notifyProvider],
+    };
+  }
+
+  /**
+   * Register async
+   * @static
+   * @param {NestjsNotificationModuleAsyncOptions} options
+   * @return DynamicModule
+   */
+  static registerAsync(options: NestjsNotificationModuleAsyncOptions): DynamicModule {
+    const notifyProvider: ValueProvider = {
+      provide: NESTJS_NOTIFICATION_OPTIONS,
+      useValue: options,
+    };
+
+    return {
+      module: NestjsNotificationModule,
+      imports: options.imports || [],
+      providers: [NestjsNotificationService, notifyProvider, ...this.createAsyncProviders(options)],
+      exports: [NestjsNotificationService, notifyProvider],
+    };
+  }
+
+  /**
+   * Create async providers
+   * @private
+   * @param {NestjsNotificationModuleAsyncOptions} options
+   * @return Provider[]
+   */
+  private static createAsyncProviders(options: NestjsNotificationModuleAsyncOptions): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncConfigProvider(options)];
+    } else if (!options.useClass) {
+      return [
+        {
+          provide: NESTJS_NOTIFICATION_OPTIONS,
+          useValue: {},
+          inject: options.inject || [],
+        },
+      ];
+    }
+
+    return [
+      this.createAsyncConfigProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ];
+  }
+
+  /**
+   * Create async config provider
+   * @private
+   * @param {NestjsNotificationModuleAsyncOptions} options
+   * @return Provider<any>
+   */
+  private static createAsyncConfigProvider(
+    options: NestjsNotificationModuleAsyncOptions,
+  ): Provider<any> {
+    if (options.useFactory) {
+      return {
+        provide: NESTJS_NOTIFICATION_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+
+    const inject = options.useClass || options.useExisting;
+
+    if (!inject) {
+      throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+
+    return {
+      provide: NESTJS_NOTIFICATION_OPTIONS,
+      async useFactory(
+        optionsFactory: NestjsNotificationModuleOptionsFactory,
+      ): Promise<NestjsNotificationModuleOptions> {
+        return optionsFactory.createNestjsNotificationOptions();
+      },
+      inject: [inject],
+    };
+  }
+}

lib/nestjs-notify.service.ts → lib/nestjs-notification.service.ts

@@ -1,14 +1,15 @@
 import { Injectable, Type } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { INestjsNotifyChannel, NestJsNotify } from './interfaces';
+import { INestjsNotificationChannel, NestJsNotification } from './interfaces';
 
 @Injectable()
-export class NestjsNotifyService {
+export class NestjsNotificationService {
   /**
    * Resolve the channel needed to send the Notification
    * @param channel
    */
-  private resolveChannel = (channel: Type<INestjsNotifyChannel>) => this.moduleRef.create(channel);
+  private resolveChannel = (channel: Type<INestjsNotificationChannel>) =>
+    this.moduleRef.create(channel);
 
   /**
    * @constructor
@@ -18,26 +19,26 @@ export class NestjsNotifyService {
 
   /**
    * Process a notification and send via designated channel
-   * @param {NestJsNotify} notification
+   * @param {NestJsNotification} notification
    */
-  public send(notification: NestJsNotify): Promise<any> {
+  public send(notification: NestJsNotification): Promise<any> {
     const channels = notification.sendToChannels();
 
     return Promise.all(
-      channels.map((channel: Type<INestjsNotifyChannel>) =>
+      channels.map((channel: Type<INestjsNotificationChannel>) =>
         this.sendOnChannel(notification, channel),
       ),
     );
   }
 
   /**
    * Send notification on designated channel
-   * @param {NestJsNotify} notification
-   * @param {Type<INestjsNotifyChannel>} clientChannel
+   * @param {NestJsNotification} notification
+   * @param {Type<INestjsNotificationChannel>} clientChannel
    */
   private async sendOnChannel(
-    notification: NestJsNotify,
-    clientChannel: Type<INestjsNotifyChannel>,
+    notification: NestJsNotification,
+    clientChannel: Type<INestjsNotificationChannel>,
   ): Promise<any> {
     return (await this.resolveChannel(clientChannel)).send(notification);
   }