GitBook: [taskforcesh#104] No subject

docs/gitbook/SUMMARY.md

@@ -56,7 +56,8 @@
 
 * [Introduction](bullmq-pro/introduction.md)
 * [Install](bullmq-pro/install.md)
-* [Observables](bullmq-pro/observables.md)
+* [Observables](bullmq-pro/observables/README.md)
+  * [Cancelation](bullmq-pro/observables/cancelation.md)
 * [Groups](bullmq-pro/groups/README.md)
   * [Rate limiting](bullmq-pro/groups/rate-limiting.md)
   * [Concurrency](bullmq-pro/groups/concurrency.md)

docs/gitbook/bull/introduction.md

@@ -6,9 +6,9 @@ Bull is the legacy version of BullMQ. As it is still heavily used today, it is a
 
 Bull has been a part of the NodeJS ecosystem for a long time and is used by many organizations both in commercial and open-source projects. A few special mentions:
 
-![](<../.gitbook/assets/Screenshot 2022-02-15 at 11.32.39 (1).png>)![](../.gitbook/assets/mozilla-logo-bw-rgb.png)![](../.gitbook/assets/autodesk-logo-white.png)![](../.gitbook/assets/Atlassian-horizontal-blue-rgb.webp)
+![](<../.gitbook/assets/Screenshot 2022-02-15 at 11.32.39 (1).png>)![](<../.gitbook/assets/mozilla-logo-bw-rgb (2).png>)![](../.gitbook/assets/autodesk-logo-white.png)![](<../.gitbook/assets/Atlassian-horizontal-blue-rgb (1).webp>)
 
-![](../.gitbook/assets/midwayjs-logo.png)![](<../.gitbook/assets/salesforce-logo (1).png>)
+![](../.gitbook/assets/midwayjs-logo.png)![](../.gitbook/assets/salesforce-logo.png)
 
 ![](<../.gitbook/assets/entethalliance-logo (1).png>)![](../.gitbook/assets/kisspng-logo-retail-target-corporation-advertising-5ae5ef43944c89.3404142515250184356074.png)
 

docs/gitbook/bullmq-pro/observables/README.md

@@ -0,0 +1,62 @@
+# Observables
+
+Instead of returning regular promises, your workers can also return an Observable, this allows for some more advanced uses cases:
+
+* It makes it possible to cleanly cancel a running job.
+* You can define a "Time to live" (TTL) so that jobs that take too long time will be automatically canceled.
+* Since the last value returned by the observable is persisted, you could retry a job and continue where you left of, for example, if the job implements a state machine or similar.
+
+If you are new to Observables you may want to read this [introduction](https://www.learnrxjs.io/learn-rxjs/concepts/rxjs-primer). The two biggest advantages that Observables have over Promises are that they can emit more than 1 value and that they are cancelable.
+
+Let's see a silly example of a worker making use of Observables:
+
+```typescript
+import { WorkerPro } from "@taskforcesh/bullmq-pro"
+import { Observable } from "rxjs"
+
+const processor = async () => {
+  return new Observable<number>(subscriber => {
+    subscriber.next(1);
+    subscriber.next(2);
+    subscriber.next(3);
+    const intervalId = setTimeout(() => {
+      subscriber.next(4);
+      subscriber.complete();
+    }, 500);
+
+    // Provide a way of canceling and disposing the interval resource
+    return function unsubscribe() {
+      clearInterval(intervalId);
+    };
+  });
+};
+
+const worker = new WorkerPro(queueName, processor, { connection });
+
+```
+
+In the example above, the observable will emit 4 values, the first 3 directly and then a 4th after 500 ms. Also note that the "subscriber" returns a "unsubscribe" function. This is the function that will be called if the Observable is cancelled, so this is where you would do the necessary clean up.
+
+You may be asking whats the use of returning several values for a worker. One case that comes to mind is if you have a larger processor and you want to make sure that if the process crashes you can continue from the latest value. You could do this with a simple switch-case on the return value, something like this:
+
+```typescript
+import { WorkerPro } from "@taskforcesh/bullmq-pro"
+import { Observable } from "rxjs"
+
+const processor = async (job) => {
+  return new Observable<number>(subscriber => {
+    switch(job.returnvalue){
+      default:
+        subscriber.next(1);
+      case 1:
+        subscriber.next(2);
+      case 2:
+        subscriber.next(3);
+      case 3:
+        subscriber.complete();
+    }
+  });
+};
+
+const worker = new WorkerPro(queueName, processor, { connection });
+```

docs/gitbook/bullmq-pro/observables/cancelation.md

@@ -0,0 +1,12 @@
+# Cancelation
+
+As mentioned, Observables allows for clean cancelation. Currently we support a TTL value that defines the maximum processing time before the job is finally cancelled:
+
+```typescript
+import { WorkerPro } from "@taskforcesh/bullmq-pro"
+
+const worker = new WorkerPro(queueName, processor, {
+  ttl: 100,
+  connection,
+});
+```

docs/gitbook/guide/jobs/getters.md

@@ -2,7 +2,7 @@
 
 When jobs are added to a queue, they will be in different statuses during their lifetime. BullMQ provides methods to retrieve information and jobs from the different statuses.
 
-![Lifecycle of a job](../../.gitbook/assets/architecture.png)
+![Lifecycle of a job](../../.gitbook/assets/complete-architecture.png)
 
 #### Job Counts