docs(): minor tweaks

Author: kamilmysliwiec

content/techniques/queues.md

@@ -341,6 +341,44 @@ To resume a paused queue, use the `resume()` method, as follows:
 await audioQueue.resume();
 ```
 
+#### Separate processes
+
+Job handlers can also be run in a separate (forked) process ([source](https://github.com/OptimalBits/bull#separate-processes)). This has several advantages:
+
+- The process is sandboxed so if it crashes it does not affect the worker.
+- You can run blocking code without affecting the queue (jobs will not stall).
+- Much better utilization of multi-core CPUs.
+- Less connections to redis.
+
+```ts
+@@filename(app.module)
+import { Module } from '@nestjs/common';
+import { BullModule } from '@nestjs/bull';
+import { join } from 'path';
+
+@Module({
+  imports: [
+    BullModule.registerQueue({
+      name: 'audio',
+      processors: [join(__dirname, 'processor.js')],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Please note that because your function is being executed in a forked process, Dependency Injection (and IoC container) won't be available. That means that your processor function will need to contain (or create) all instances of external dependencies it needs.
+
+```ts
+@@filename(processor)
+import { Job, DoneCallback } from 'bull';
+
+export default function (job: Job, cb: DoneCallback) {
+  console.log(`[${process.pid}] ${JSON.stringify(job.data)}`);
+  cb(null, 'It works');
+}
+```
+
 #### Async configuration
 
 You may want to pass `bull` options asynchronously instead of statically. In this case, use the `forRootAsync()` method which provides several ways to deal with async configuration. Likewise, if you want to pass queue options asynchronously, use the `registerQueueAsync()` method.
@@ -408,40 +446,6 @@ BullModule.forRootAsync({
 
 This construction works the same as `useClass` with one critical difference - `BullModule` will lookup imported modules to reuse an existing `ConfigService` instead of instantiating a new one.
 
-#### Separate processes
-
-This module allows you to run your job handlers in fork processes.
-To do so, add the filesystem path to a file (or more) exporting your processor function to the `processors` property of the BullModule options.
-You can read more on this subject in Bull's [documentation](https://github.com/OptimalBits/bull#separate-processes).
-
-Please note that because your function is being executed in a fork, NestJS' Dependency Injection won't be available. This means your job function will need to contain, or create all instances of external dependencies it may need.
-
-```ts
-@@filename(app.module.ts)
-import { Module } from '@nestjs/common';
-import { BullModule } from 'nest-bull';
-import { join } from 'path';
-
-@Module({
-  imports: [
-    BullModule.forRoot({
-      processors: [join(__dirname, 'processor.js')],
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-```ts
-@@filename(process.ts)
-import { Job, DoneCallback } from 'bull';
-
-export default function (job: Job, cb: DoneCallback) {
-  console.log(`[${process.pid}] ${JSON.stringify(job.data)}`);
-  cb(null, 'It works');
-}
-```
-
 #### Example
 
 A working example is available [here](https://github.com/nestjs/nest/tree/master/sample/26-queues).