refactor(configuration): Remove ConfigurationService class

and use a plain object `RunnerOptions`

Author: madeindjs

CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## Current
+
+- **fix(hooks)**: Set all worker hooks (was only `job:success`)
+- **refactor(configuration)**: Remove `ConfigurationService` class and use a plain object `RunnerOptions`
+- **refactor()**: Rename `GraphileWorkerService` to `WorkerService`
+- **doc(license)**: add license MIT
+
+## v0.0.3-alpha
+
+- reduce dependencies
+
+## v0.0.2-alpha
+
+- initial version

src/graphile-worker.module.ts

@@ -1,14 +1,13 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { DiscoveryModule } from '@nestjs/core';
+import { EventEmitter } from 'events';
+import { RunnerOptions } from 'graphile-worker';
 import {
   GraphileWorkerAsyncConfiguration,
+  GraphileWorkerConfiguration,
   GraphileWorkerConfigurationFactory,
-  RunnerOptionWithoutEvents,
+  RUNNER_OPTIONS_KEY,
 } from './interfaces/module-config.interfaces';
-import {
-  ConfigurationService,
-  CONFIGURATION_SERVICE_KEY,
-} from './services/configuration.service';
 import { ListenerExplorerService } from './services/listener-explorer.service';
 import { MetadataAccessorService } from './services/metadata-accessor.service';
 import { WorkerService } from './services/worker.service';
@@ -42,12 +41,10 @@ export class GraphileWorkerModule {
    *  }),
    * ```
    */
-  static forRoot(config: RunnerOptionWithoutEvents): DynamicModule {
-    const configurationService = new ConfigurationService(config);
-
+  static forRoot(config: GraphileWorkerConfiguration): DynamicModule {
     const graphileConfigurationServiceProvider: Provider = {
-      provide: CONFIGURATION_SERVICE_KEY,
-      useValue: configurationService,
+      provide: RUNNER_OPTIONS_KEY,
+      useValue: config,
     };
 
     return {
@@ -102,24 +99,35 @@ export class GraphileWorkerModule {
   ): Provider {
     if (options.useFactory) {
       return {
-        provide: CONFIGURATION_SERVICE_KEY,
+        provide: RUNNER_OPTIONS_KEY,
+        inject: options.inject || [],
         useFactory: async (...args: any[]) => {
           const config = await options.useFactory(...args);
-          return new ConfigurationService(config);
+          return buildRunnerOptions(config);
         },
-        inject: options.inject || [],
       };
     }
 
     return {
-      provide: CONFIGURATION_SERVICE_KEY,
+      provide: RUNNER_OPTIONS_KEY,
+      inject: options.inject,
       useFactory: async (
         optionsFactory: GraphileWorkerConfigurationFactory,
       ) => {
         const config = await optionsFactory.createSharedConfiguration();
-        return new ConfigurationService(config);
+        return buildRunnerOptions(config);
       },
-      inject: options.inject,
     };
   }
 }
+
+function buildRunnerOptions(
+  configuration: GraphileWorkerConfiguration,
+): RunnerOptions {
+  const events = new EventEmitter();
+
+  return {
+    ...configuration,
+    events,
+  };
+}

src/interfaces/module-config.interfaces.ts

@@ -1,12 +1,17 @@
 import { FactoryProvider, ModuleMetadata } from '@nestjs/common';
 import { RunnerOptions } from 'graphile-worker';
 
-export type RunnerOptionWithoutEvents = Omit<RunnerOptions, 'events'>;
+export const RUNNER_OPTIONS_KEY = Symbol.for('RUNNER_OPTIONS_KEY');
+
+/**
+ * We use `events` internally for decorators.
+ */
+export type GraphileWorkerConfiguration = Omit<RunnerOptions, 'events'>;
 
 export interface GraphileWorkerConfigurationFactory {
   createSharedConfiguration():
-    | Promise<RunnerOptionWithoutEvents>
-    | RunnerOptionWithoutEvents;
+    | Promise<GraphileWorkerConfiguration>
+    | GraphileWorkerConfiguration;
 }
 
 export interface GraphileWorkerAsyncConfiguration
@@ -16,7 +21,7 @@ export interface GraphileWorkerAsyncConfiguration
    */
   useFactory?: (
     ...args: any[]
-  ) => Promise<RunnerOptionWithoutEvents> | RunnerOptionWithoutEvents;
+  ) => Promise<GraphileWorkerConfiguration> | GraphileWorkerConfiguration;
 
   /**
    * Optional list of providers to be injected into the context of the Factory function.

src/services/configuration.service.ts

@@ -1,8 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import {
-  ConfigurationService,
-  CONFIGURATION_SERVICE_KEY,
-} from './configuration.service';
+import { RunnerOptions } from 'graphile-worker';
+import { RUNNER_OPTIONS_KEY } from '../interfaces/module-config.interfaces';
 import { ListenerExplorerService } from './listener-explorer.service';
 import { WorkerService } from './worker.service';
 
@@ -20,14 +18,11 @@ describe(WorkerService.name, () => {
           },
         },
         {
-          useFactory: () => {
-            const configurationService = new ConfigurationService({
-              taskList: { hello: () => {} },
-              connectionString: 'postgres://example:password@postgres/example',
-            });
-            return configurationService;
-          },
-          provide: CONFIGURATION_SERVICE_KEY,
+          provide: RUNNER_OPTIONS_KEY,
+          useValue: {
+            taskList: { hello: () => {} },
+            connectionString: 'postgres://example:password@postgres/example',
+          } as RunnerOptions,
         },
       ],
     }).compile();

src/services/worker.service.spec.ts

@@ -8,30 +8,20 @@ import {
   TaskSpec,
   WorkerUtils,
 } from 'graphile-worker';
-import {
-  ConfigurationService,
-  CONFIGURATION_SERVICE_KEY,
-} from './configuration.service';
+import { RUNNER_OPTIONS_KEY } from '../interfaces/module-config.interfaces';
+import { uniq } from '../utils/array.utils';
 import { ListenerExplorerService } from './listener-explorer.service';
 
 @Injectable()
 export class WorkerService {
   private readonly logger = new Logger(WorkerService.name);
   private isMigrationDone: boolean;
-  private readonly options: RunnerOptions;
 
   constructor(
-    @Inject(CONFIGURATION_SERVICE_KEY)
-    configuration: ConfigurationService,
+    @Inject(RUNNER_OPTIONS_KEY) private readonly options: RunnerOptions,
     private readonly explorerService: ListenerExplorerService,
   ) {
-    configuration.config.events.on('job:success', (...args: any[]) => {
-      this.explorerService.listeners
-        .filter(({ event }) => event === 'job:success')
-        .forEach(({ callback }) => callback(...args));
-    });
-
-    this.options = configuration.config;
+    this.hookEvents();
   }
 
   /**
@@ -99,4 +89,16 @@ export class WorkerService {
     this.logger.debug('Run migrations');
     this.isMigrationDone = true;
   }
+
+  private hookEvents() {
+    const events = this.explorerService.listeners.map(({ event }) => event);
+
+    for (const event of uniq(events)) {
+      this.options.events.on(event, (...args: any[]) => {
+        this.explorerService.listeners
+          .filter(({ event }) => event === event)
+          .forEach(({ callback }) => callback(...args));
+      });
+    }
+  }
 }

src/services/worker.service.ts

@@ -0,0 +1,3 @@
+export function uniq<T>(a: Array<T>): Array<T> {
+  return Array.from(new Set(a));
+}