Merge pull request #8 from chvarkov/develop

Async module initialization
chvarkov · Oct 28, 2020 · 9c90354 · 9c90354
2 parents f68ed45 + be3ccc8
commit 9c90354
Show file tree

Hide file tree

Showing 5 changed files with 193 additions and 6 deletions.
diff --git a/README.md b/README.md
@@ -32,6 +32,22 @@ export class AppModule {
 }
 ```
 
+If you want import configs from your [ConfigService](https://docs.nestjs.com/techniques/configuration#getting-started) via [custom getter function](https://docs.nestjs.com/techniques/configuration#custom-getter-functions) that will return `GoogleRecaptchaModuleOptions` object.
+
+```typescript
+@Module({
+    imports: [
+        GoogleRecaptchaModule.forRootAsync({
+            imports: [ConfigModule],
+            useFactory: (configService: ConfigService) => configService.googleRecaptchaOptions,
+            inject: [ConfigService],
+        })
+    ],
+})
+export class AppModule {
+}
+```
+
 ### Usage <a name="Usage"></a>
 
 Use `@Recaptcha` decorator to protect your endpoints.

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@nestlab/google-recaptcha",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Google recaptcha module for NestJS.",
   "keywords": [
     "nest",

diff --git a/src/google-recaptcha.module.ts b/src/google-recaptcha.module.ts
@@ -1,11 +1,13 @@
 import { DynamicModule, HttpModule, Module, Provider } from '@nestjs/common';
 import { GoogleRecaptchaGuard } from './guards/google-recaptcha.guard';
 import { GoogleRecaptchaValidator } from './services/google-recaptcha.validator';
-import { GoogleRecaptchaModuleOptions } from './interfaces/google-recaptcha-module-options';
+import {
+    GoogleRecaptchaModuleAsyncOptions,
+    GoogleRecaptchaModuleOptions, GoogleRecaptchaOptionsFactory
+} from './interfaces/google-recaptcha-module-options';
 import { RECAPTCHA_OPTIONS } from './provider.declarations';
 
-@Module({
-})
+@Module({})
 export class GoogleRecaptchaModule {
     static forRoot(options: GoogleRecaptchaModuleOptions): DynamicModule {
         const providers: Provider[] = [
@@ -17,13 +19,69 @@ export class GoogleRecaptchaModule {
             },
         ];
 
+        return {
+            module: GoogleRecaptchaModule,
+            imports: [
+                HttpModule
+            ],
+            providers: providers,
+            exports: providers,
+        }
+    }
+
+    static forRootAsync(options: GoogleRecaptchaModuleAsyncOptions): DynamicModule {
+        const providers: Provider[] = [
+            GoogleRecaptchaGuard,
+            GoogleRecaptchaValidator,
+            ...this.createAsyncProviders(options)
+        ];
+
         return {
             module: GoogleRecaptchaModule,
             imports: [
                 HttpModule,
+                ...options.imports || []
             ],
-            providers,
+            providers: providers,
             exports: providers,
         }
     }
+
+    private static createAsyncProviders(options: GoogleRecaptchaModuleAsyncOptions): Provider[] {
+        const providers: Provider[] = [this.createAsyncOptionsProvider(options)];
+
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass,
+            });
+        }
+
+        return providers;
+    }
+
+    private static createAsyncOptionsProvider(options: GoogleRecaptchaModuleAsyncOptions): Provider {
+        if (options.useFactory) {
+            return {
+                provide: RECAPTCHA_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+
+        return {
+            provide: RECAPTCHA_OPTIONS,
+            useFactory: (optionsFactory: GoogleRecaptchaOptionsFactory) => {
+                if (!this.isGoogleRecaptchaFactory(optionsFactory)) {
+                    throw new Error('Factory must be implement \'GoogleRecaptchaOptionsFactory\' interface.')
+                }
+                return optionsFactory.createGoogleRecaptchaOptions();
+            },
+            inject: [options.useExisting! || options.useClass!],
+        };
+    }
+
+    private static isGoogleRecaptchaFactory(object: any): object is GoogleRecaptchaOptionsFactory {
+        return !!object && typeof object.createGoogleRecaptchaOptions === 'function';
+    }
 }
diff --git a/src/interfaces/google-recaptcha-module-options.ts b/src/interfaces/google-recaptcha-module-options.ts
@@ -1,5 +1,16 @@
 import { GoogleRecaptchaGuardOptions } from './google-recaptcha-guard-options';
 import { GoogleRecaptchaValidatorOptions } from './google-recaptcha-validator-options';
+import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
 
-export interface GoogleRecaptchaModuleOptions extends GoogleRecaptchaValidatorOptions, GoogleRecaptchaGuardOptions {
+export interface GoogleRecaptchaModuleOptions extends GoogleRecaptchaValidatorOptions, GoogleRecaptchaGuardOptions {}
+
+export interface GoogleRecaptchaOptionsFactory {
+    createGoogleRecaptchaOptions(): Promise<GoogleRecaptchaModuleOptions> | GoogleRecaptchaModuleOptions;
 }
+
+export interface GoogleRecaptchaModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useClass?: Type<GoogleRecaptchaOptionsFactory>;
+    useExisting?: Type<GoogleRecaptchaOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<GoogleRecaptchaModuleOptions> | GoogleRecaptchaModuleOptions;
+}
diff --git a/test/google-recaptcha-async-module.spec.ts b/test/google-recaptcha-async-module.spec.ts
@@ -0,0 +1,102 @@
+import { Test } from '@nestjs/testing';
+import { Module } from '@nestjs/common';
+import { GoogleRecaptchaValidator } from '../src/services/google-recaptcha.validator';
+import { GoogleRecaptchaModule } from '../src/google-recaptcha.module';
+import { GoogleRecaptchaModuleOptions } from '../src';
+import { GoogleRecaptchaOptionsFactory } from '../src/interfaces/google-recaptcha-module-options';
+
+export class GoogleRecaptchaModuleOptionsFactory implements GoogleRecaptchaOptionsFactory {
+    createGoogleRecaptchaOptions(): Promise<GoogleRecaptchaModuleOptions> {
+        return Promise.resolve(new TestConfigService().getGoogleRecaptchaOptions());
+    }
+}
+
+export class TestConfigService {
+    getGoogleRecaptchaOptions(): GoogleRecaptchaModuleOptions {
+        return {
+            secretKey: 'secret',
+            response: req => req.body.recaptcha,
+            skipIf: () => true,
+        };
+    }
+}
+
+@Module({
+    providers: [
+        TestConfigService,
+        GoogleRecaptchaModuleOptionsFactory,
+    ],
+    exports: [
+        TestConfigService,
+        GoogleRecaptchaModuleOptionsFactory,
+    ],
+})
+export class TestConfigModule {
+
+}
+
+describe('Google recaptcha async module', () => {
+    test('Test via import module',  async () => {
+        const testingModule = await Test.createTestingModule({
+            imports: [
+                GoogleRecaptchaModule.forRootAsync({
+                    imports: [TestConfigModule],
+                    useFactory: (config: TestConfigService) => config.getGoogleRecaptchaOptions(),
+                    inject: [
+                        TestConfigService,
+                    ],
+                }),
+            ],
+        }).compile();
+
+        const app = testingModule.createNestApplication();
+
+        const validator = app.get(GoogleRecaptchaValidator);
+        expect(validator).toBeInstanceOf(GoogleRecaptchaValidator);
+    });
+
+    test('Test via useClass',  async () => {
+        const testingModule = await Test.createTestingModule({
+            imports: [
+                GoogleRecaptchaModule.forRootAsync({
+                    useClass: GoogleRecaptchaModuleOptionsFactory,
+                }),
+            ],
+        }).compile();
+
+        const app = testingModule.createNestApplication();
+
+        const validator = app.get(GoogleRecaptchaValidator);
+        expect(validator).toBeInstanceOf(GoogleRecaptchaValidator);
+    });
+
+    test('Test via useExisting',  async () => {
+        const testingModule = await Test.createTestingModule({
+            imports: [
+                GoogleRecaptchaModule.forRootAsync({
+                    imports: [
+                        TestConfigModule,
+                    ],
+                    useExisting: GoogleRecaptchaModuleOptionsFactory,
+                }),
+            ],
+        }).compile();
+
+        const app = testingModule.createNestApplication();
+
+        const validator = app.get(GoogleRecaptchaValidator);
+        expect(validator).toBeInstanceOf(GoogleRecaptchaValidator);
+    });
+
+    test('Test via useClass that not implement GoogleRecaptchaOptionsFactory',  async () => {
+        await Test.createTestingModule({
+            imports: [
+                GoogleRecaptchaModule.forRootAsync({
+                    useClass: TestConfigModule as any,
+                }),
+            ],
+        }).compile()
+            .then(() => expect(true).toBeFalsy())
+            .catch(e => expect(e.message).toBe('Factory must be implement \'GoogleRecaptchaOptionsFactory\' interface.'));
+    });
+});