feat(module): added forRootAsync method to the CouchbaseModule

Author: michaelyali

dist/README.md

@@ -92,6 +92,6 @@ Created by [@zMotivat0r](https://github.com/zMotivat0r) @ [Scalio](https://scal.
 <p align="center">
     <br/>
     <a href="https://scal.io/">
-        <img src="https://raw.githubusercontent.com/scalio/bazel-nestjs-starter/master/readme-assets/scalio.png"/>
+        <img src="https://raw.githubusercontent.com/scalio/bazel-status/master/assets/scalio-logo.svg?sanitize=true"/>
     </a>
 </p>

dist/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scalio-oss/nest-couchbase",
   "description": "Couchbase module for Nest framework",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "main": "index.js",
   "typings": "index.d.ts",

e2e/__stubs__/cats.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@nestjs/common';
+
+import { InjectRepository, Repository } from '../../src';
+import { Cat } from './cat.entity';
+
+@Injectable()
+export class CatsService {
+  constructor(@InjectRepository(Cat) public repo: Repository<Cat>) {}
+}

e2e/__stubs__/index.ts

@@ -1,2 +1,3 @@
 export * from './config';
 export * from './cat.entity';
+export * from './cats.service';

e2e/couchbase/couchbase.repository.mixin.spec.ts

@@ -0,0 +1,103 @@
+import { Test } from '@nestjs/testing';
+import { INestApplication, Injectable, Module, Global } from '@nestjs/common';
+import { CouchbaseError } from 'couchbase';
+
+import { CouchbaseConnectionFactory } from '../../src/couchbase/couchbase.connection.factory';
+import { CouchbaseModule } from '../../src/module/couchbase.module';
+import { sleep, flattenPromise } from '../../src/utils';
+import { config, bucketOptions, Cat, CatsService } from '../__stubs__';
+
+describe('#module', () => {
+  describe('#CouchbaseModule', () => {
+    const msg = 'The key does not exist on the server';
+    let app: INestApplication;
+    let conn: CouchbaseConnectionFactory;
+    let service: CatsService;
+
+    async function removeBuckets() {
+      const [_, buckets] = await conn.listBuckets();
+      if (buckets && buckets.length) {
+        for (let i = 0; i < buckets.length; i++) {
+          await conn.removeBucket(buckets[0].name);
+        }
+      }
+    }
+
+    beforeAll(async () => {
+      conn = await CouchbaseConnectionFactory.create(config);
+      await removeBuckets();
+      await conn.createBucket(config.bucket, bucketOptions);
+      await sleep(3500);
+    });
+
+    afterAll(async () => {
+      const [_, bucket] = await conn.getBucket(config.bucket);
+      bucket.disconnect();
+      await removeBuckets();
+    });
+
+    describe('#forRoot && forFeature', () => {
+      beforeAll(async () => {
+        const fixture = await Test.createTestingModule({
+          imports: [CouchbaseModule.forRoot(config), CouchbaseModule.forFeature([Cat])],
+          providers: [CatsService],
+        }).compile();
+        app = fixture.createNestApplication();
+        await app.init();
+        service = app.get<CatsService>(CatsService);
+      });
+
+      afterAll(async () => {
+        await app.close();
+      });
+
+      it('should throw an error', async () => {
+        const [err] = await flattenPromise(service.repo.get)('key');
+        expect(err.message).toBe(msg);
+      });
+    });
+
+    describe('#forRootAsync && forFeature', () => {
+      beforeAll(async () => {
+        @Injectable()
+        class ConfigService {
+          constructor() {}
+          get() {
+            return config;
+          }
+        }
+
+        @Global()
+        @Module({
+          providers: [ConfigService],
+          exports: [ConfigService],
+        })
+        class ConfigModule {}
+
+        const fixture = await Test.createTestingModule({
+          imports: [
+            ConfigModule,
+            CouchbaseModule.forRootAsync({
+              useFactory: (configService: ConfigService) => configService.get(),
+              inject: [ConfigService],
+            }),
+            CouchbaseModule.forFeature([Cat]),
+          ],
+          providers: [CatsService],
+        }).compile();
+        app = fixture.createNestApplication();
+        await app.init();
+        service = app.get<CatsService>(CatsService);
+      });
+
+      afterAll(async () => {
+        await app.close();
+      });
+
+      it('should throw an error', async () => {
+        const [err] = await flattenPromise(service.repo.get)('key');
+        expect(err.message).toBe(msg);
+      });
+    });
+  });
+});

e2e/module/couchbase.module.spec.ts

@@ -1,7 +1,7 @@
 {
   "name": "@scalio-oss/nest-couchbase",
   "description": "Couchbase module for Nest framework",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "private": true,
   "scripts": {
@@ -11,7 +11,6 @@
     "commit": "npx git-cz",
     "lint": "npx tslint 'src/*.ts'",
     "format": "npx pretty-quick --pattern 'src/**/*.ts'",
-    "test": "npx jest -c=jest.config.js test/ --verbose --runInBand",
     "test:e2e": "npx jest -c=jest.config.js e2e/ --verbose --runInBand",
     "start": "npx nodemon -w ./integration -e ts node_modules/.bin/ts-node integration/main.ts"
   },

package.json

@@ -1 +1,2 @@
 export const COUCHBASE_CONNECTION_TOKEN = 'COUCHBASE_CONNECTION_TOKEN';
+export const COUCHBASE_MODULE_OPTIONS = 'COUCHBASE_MODULE_OPTIONS';

src/module/constants.ts

@@ -1,13 +1,41 @@
-import { Global, Module, DynamicModule } from '@nestjs/common';
+import {
+  Global,
+  Module,
+  DynamicModule,
+  Provider,
+  OnApplicationShutdown,
+} from '@nestjs/common';
 
-import { CouchbaseConnectionConfig } from '../couchbase';
-import { createCouchbaseConnectionProviders } from './providers';
+import { CouchbaseConnectionConfig, CouchbaseConnectionFactory } from '../couchbase';
+import { CouchbaseModuleAsyncOptions } from './interfaces';
+import {
+  createCouchbaseConnectionProviders,
+  createCouchbaseAsyncConnectionProviders,
+} from './providers';
+import { InjectConnection } from './couchbase.decorators';
 
 @Global()
 @Module({})
-export class CouchbaseCoreModule {
+export class CouchbaseCoreModule implements OnApplicationShutdown {
+  constructor(@InjectConnection() private conn: CouchbaseConnectionFactory) {}
+
+  onApplicationShutdown() {
+    Object.keys(this.conn.buckets).forEach((bucket) =>
+      this.conn.buckets[bucket].disconnect(),
+    );
+  }
+
   static forRoot(config: CouchbaseConnectionConfig): DynamicModule {
     const providers = createCouchbaseConnectionProviders(config);
+    return CouchbaseCoreModule.outputDynamicModule(providers);
+  }
+
+  static forRootAsync(options: CouchbaseModuleAsyncOptions): DynamicModule {
+    const providers = createCouchbaseAsyncConnectionProviders(options);
+    return CouchbaseCoreModule.outputDynamicModule(providers);
+  }
+
+  private static outputDynamicModule(providers: Provider[]): DynamicModule {
     return {
       module: CouchbaseCoreModule,
       providers,

src/module/couchbase-core.module.ts

@@ -1,6 +1,7 @@
 import { Module, DynamicModule } from '@nestjs/common';
 
 import { CouchbaseConnectionConfig } from '../couchbase';
+import { CouchbaseModuleAsyncOptions } from './interfaces';
 import { CouchbaseCoreModule } from './couchbase-core.module';
 import { createCouchbaseProviders } from './providers';
 
@@ -13,6 +14,13 @@ export class CouchbaseModule {
     };
   }
 
+  static forRootAsync(options: CouchbaseModuleAsyncOptions): DynamicModule {
+    return {
+      module: CouchbaseModule,
+      imports: [CouchbaseCoreModule.forRootAsync(options)],
+    };
+  }
+
   static forFeature(entities: Function[]): DynamicModule {
     const providers = createCouchbaseProviders(entities);
     return {