Add runner

Author: madeindjs

README.md

@@ -1,28 +1,72 @@
 # [Graphile Worker](https://github.com/graphile/worker) for [Nest](https://github.com/nestjs/nest)
 
+This is wrapper for Nest.js and [Graphile Worker](https://github.com/graphile/worker).
+
+What is Graphile worker ?
+
 > Job queue for PostgreSQL running on Node.js - allows you to run jobs (e.g. sending emails, performing calculations, generating PDFs, etc) "in the background" so that your HTTP response/application code is not held up. Can be used with any PostgreSQL-backed application. Pairs beautifully with [PostGraphile](https://www.graphile.org/postgraphile/) or [PostgREST](http://postgrest.org/).
 
-## Description
+Why you should prefer Graphile Worker instead of [Bull](https://github.com/nestjs/bull) ?
 
-framework TypeScript starter repository.
+1. You already have a PostgreSQL in your stack (and you don't want to add a Redis server)
 
 ## Installation
 
 ```bash
-$ npm install
+$ npm install nest-graphile-worker
 ```
 
-## Running the app
+Then import module
+
+```ts
+// src/app.module.ts
+import { GraphileWorkerModule } from 'nest-graphile-worker';
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+
+@Module({
+  imports: [
+    GraphileWorkerModule.forRoot({
+      connectionString: 'postgres://example:password@postgres/example',
+    }),
+  ],
+  controllers: [AppController],
+  providers: [],
+})
+export class AppModule {}
+```
 
-```bash
-# development
-$ npm run start
+Now you can add jobs using `GraphileWorkerService`
+
+```ts
+import { GraphileWorkerService } from 'graphile-worker';
+import { Controller, HttpCode, Post } from '@nestjs/common';
+
+@Controller()
+export class AppController {
+  constructor(private readonly graphileWorker: GraphileWorkerService) {}
+
+  @Post()
+  @HttpCode(201)
+  async addJob() {
+    await this.graphileWorker.quickAddJob('test', { hello: 'world' });
+  }
+}
+```
+
+Also you can run worker in bacground in `main.ts` file:
 
-# watch mode
-$ npm run start:dev
+```ts
+import { GraphileWorkerService } from '@app/graphile-worker';
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
 
-# production mode
-$ npm run start:prod
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.get(GraphileWorkerService).run();
+  await app.listen(3000);
+}
+bootstrap();
 ```
 
 ## Test

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

@@ -1,5 +1,5 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
-import { WorkerUtilsOptions } from 'graphile-worker';
+import { RunnerOptions } from 'graphile-worker';
 import { GraphileWorkerService } from './graphile-worker.service';
 
 export const GRAPHILE_WORKER_TOKEN = Symbol.for('NestJsGraphileWorker');
@@ -9,21 +9,7 @@ export const GRAPHILE_WORKER_TOKEN = Symbol.for('NestJsGraphileWorker');
   exports: [GraphileWorkerService],
 })
 export class GraphileWorkerModule {
-  static forRoot(options: WorkerUtilsOptions): DynamicModule;
-  static forRoot(connectionString: string): DynamicModule;
-  static forRoot(connectionStringOrOptions: unknown): DynamicModule {
-    let options: WorkerUtilsOptions = {};
-
-    if (typeof connectionStringOrOptions === 'string') {
-      options.connectionString = connectionStringOrOptions;
-    } else if (isWorkerUtilsOptions(connectionStringOrOptions)) {
-      options = connectionStringOrOptions;
-    } else {
-      throw Error(
-        'Cannot detect type of option provided for `GraphileWorkerModule.forRoot()`',
-      );
-    }
-
+  static forRoot(options: RunnerOptions): DynamicModule {
     const graphileWorkerService: Provider = {
       provide: GraphileWorkerService,
       useValue: new GraphileWorkerService(options),
@@ -37,7 +23,3 @@ export class GraphileWorkerModule {
     };
   }
 }
-
-function isWorkerUtilsOptions(options: unknown): options is WorkerUtilsOptions {
-  return (options as WorkerUtilsOptions).connectionString !== undefined;
-}

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

@@ -2,17 +2,30 @@ import { Injectable, Logger } from '@nestjs/common';
 import {
   Job,
   quickAddJob,
+  run,
   runMigrations,
+  RunnerOptions,
   TaskSpec,
-  WorkerUtilsOptions,
 } from 'graphile-worker';
 
 @Injectable()
 export class GraphileWorkerService {
   private readonly logger = new Logger(GraphileWorkerService.name);
   private isMigrationDone: boolean;
 
-  constructor(private readonly options: WorkerUtilsOptions) {}
+  constructor(private readonly options: RunnerOptions) {}
+
+  /**
+   * Run a new worker
+   */
+  async run() {
+    await this.runMigrations();
+
+    this.logger.debug('Start runner');
+
+    const runner = await run(this.options);
+    return runner.promise;
+  }
 
   async quickAddJob(
     identifier: string,

src/app.controller.ts

@@ -8,6 +8,6 @@ export class AppController {
   @Post()
   @HttpCode(201)
   async addJob() {
-    await this.graphileWorker.quickAddJob('test', { hello: 'world' });
+    await this.graphileWorker.quickAddJob('hello', { hello: 'world' });
   }
 }

src/app.module.ts

@@ -1,11 +1,15 @@
 import { GraphileWorkerModule } from '@app/graphile-worker';
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
+import { helloTask } from './hello.task';
 
 @Module({
   imports: [
     GraphileWorkerModule.forRoot({
       connectionString: 'postgres://example:password@postgres/example',
+      taskList: {
+        hello: helloTask,
+      },
     }),
   ],
   controllers: [AppController],

src/hello.task.ts

@@ -0,0 +1,5 @@
+import { Helpers } from 'graphile-worker';
+
+export function helloTask(payload: any, helpers: Helpers) {
+  console.log(`hello task %o`, payload);
+}

src/main.ts

@@ -1,8 +1,10 @@
+import { GraphileWorkerService } from '@app/graphile-worker';
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  app.get(GraphileWorkerService).run();
   await app.listen(3000);
 }
 bootstrap();