feat(module): add GraphileWorkerService.forRootAsync

Author: madeindjs

.env

@@ -0,0 +1 @@
+PG_CONNECTION=postgres://example:password@postgres/example

README.md

@@ -16,7 +16,11 @@ Why you should prefer Graphile Worker instead of [Bull](https://github.com/nestj
 $ npm install nest-graphile-worker
 ```
 
-Then import module
+## Usage
+
+### Import module
+
+You can use `GraphileWorkerModule.forRoot`:
 
 ```ts
 // src/app.module.ts
@@ -28,6 +32,9 @@ import { AppController } from './app.controller';
   imports: [
     GraphileWorkerModule.forRoot({
       connectionString: 'postgres://example:password@postgres/example',
+      taskList: {
+        hello: helloTask,
+      },
     }),
   ],
   controllers: [AppController],
@@ -36,10 +43,41 @@ import { AppController } from './app.controller';
 export class AppModule {}
 ```
 
-Now you can add jobs using `GraphileWorkerService`
+Or you can use `GraphileWorkerModule.forRootAsync`:
 
 ```ts
-import { GraphileWorkerService } from 'graphile-worker';
+import { GraphileWorkerModule } from '@app/graphile-worker';
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AppController } from './app.controller';
+import { helloTask } from './hello.task';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    GraphileWorkerModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        connectionString: config.get('PG_CONNECTION'),
+        taskList: {
+          hello: helloTask,
+        },
+      }),
+    }),
+  ],
+  controllers: [AppController],
+  providers: [],
+})
+export class AppModule {}
+```
+
+## Create jobs
+
+You may use `GraphileWorkerService`:
+
+```ts
+import { GraphileWorkerService } from '@app/graphile-worker';
 import { Controller, HttpCode, Post } from '@nestjs/common';
 
 @Controller()
@@ -49,12 +87,26 @@ export class AppController {
   @Post()
   @HttpCode(201)
   async addJob() {
-    await this.graphileWorker.quickAddJob('test', { hello: 'world' });
+    await this.graphileWorker.addJob('hello', { hello: 'world' });
+  }
+
+  @Post('bulk')
+  @HttpCode(201)
+  async addJobs() {
+    const jobs: Array<{ identifier: string; payload?: unknown }> = new Array(
+      100,
+    )
+      .fill(undefined)
+      .map((_, i) => ({ identifier: 'hello', payload: { hello: i } }));
+
+    return this.graphileWorker.addJobs(jobs);
   }
 }
 ```
 
-Also you can run worker in bacground in `main.ts` file:
+## Start runner
+
+Add `GraphileWorkerService.run` in `main.ts` file:
 
 ```ts
 import { GraphileWorkerService } from '@app/graphile-worker';

libs/graphile-worker/src/config.interface.ts

@@ -0,0 +1,35 @@
+import { FactoryProvider, ModuleMetadata } from '@nestjs/common';
+import { RunnerOptions } from 'graphile-worker';
+
+export type GraphileWorkerConfiguration = RunnerOptions;
+
+export interface GraphileWorkerConfigurationFactory {
+  createSharedConfiguration():
+    | Promise<GraphileWorkerConfiguration>
+    | GraphileWorkerConfiguration;
+}
+
+export interface GraphileWorkerAsyncConfiguration
+  extends Pick<ModuleMetadata, 'imports'> {
+  /**
+   * Existing Provider to be used.
+   */
+  // useExisting?: Type<GraphileWorkerConfigurationFactory>;
+
+  /**
+   * Type (class name) of provider (instance to be registered and injected).
+   */
+  // useClass?: Type<GraphileWorkerConfigurationFactory>;
+
+  /**
+   * Factory function that returns an instance of the provider to be injected.
+   */
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<GraphileWorkerConfiguration> | GraphileWorkerConfiguration;
+
+  /**
+   * Optional list of providers to be injected into the context of the Factory function.
+   */
+  inject?: FactoryProvider['inject'];
+}

libs/graphile-worker/src/graphile-worker.module.ts

@@ -1,5 +1,9 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
-import { RunnerOptions } from 'graphile-worker';
+import {
+  GraphileWorkerAsyncConfiguration,
+  GraphileWorkerConfiguration,
+  GraphileWorkerConfigurationFactory,
+} from './config.interface';
 import { GraphileWorkerService } from './graphile-worker.service';
 
 export const GRAPHILE_WORKER_TOKEN = Symbol.for('NestJsGraphileWorker');
@@ -9,10 +13,13 @@ export const GRAPHILE_WORKER_TOKEN = Symbol.for('NestJsGraphileWorker');
   exports: [GraphileWorkerService],
 })
 export class GraphileWorkerModule {
-  static forRoot(options: RunnerOptions): DynamicModule {
+  /**
+   * Registers a globally available `GraphileWorkerService`.
+   */
+  static forRoot(config: GraphileWorkerConfiguration): DynamicModule {
     const graphileWorkerService: Provider = {
       provide: GraphileWorkerService,
-      useValue: new GraphileWorkerService(options),
+      useValue: new GraphileWorkerService(config),
     };
 
     return {
@@ -22,4 +29,51 @@ export class GraphileWorkerModule {
       exports: [graphileWorkerService],
     };
   }
+
+  static forRootAsync(
+    asyncConfig: GraphileWorkerAsyncConfiguration,
+  ): DynamicModule {
+    const providers = this.createAsyncSharedConfigurationProviders(asyncConfig);
+
+    return {
+      global: true,
+      module: GraphileWorkerModule,
+      imports: asyncConfig.imports,
+      providers,
+      exports: providers,
+    };
+  }
+
+  private static createAsyncSharedConfigurationProviders(
+    options: GraphileWorkerAsyncConfiguration,
+  ): Provider[] {
+    return [this.createAsyncSharedConfigurationProvider(options)];
+  }
+
+  private static createAsyncSharedConfigurationProvider(
+    options: GraphileWorkerAsyncConfiguration,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: GraphileWorkerService,
+        useFactory: async (...args: any[]) => {
+          const configuration = await options.useFactory(...args);
+          return new GraphileWorkerService(configuration);
+        },
+        inject: options.inject || [],
+      };
+    }
+
+    return {
+      provide: GraphileWorkerService,
+      useFactory: async (
+        optionsFactory: GraphileWorkerConfigurationFactory,
+      ) => {
+        const configuration = await optionsFactory.createSharedConfiguration();
+
+        return new GraphileWorkerService(configuration);
+      },
+      inject: options.inject,
+    };
+  }
 }

package-lock.json

@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@nestjs/common": "^8.0.0",
+    "@nestjs/config": "^1.0.1",
     "@nestjs/core": "^8.0.0",
     "@nestjs/platform-express": "^8.0.0",
     "graphile-worker": "^0.11.4",