fix: accept synchronous Queue.run callbacks (#516)

Author: bensynapse

src/index.ts

@@ -167,7 +167,7 @@ export class Queue<T = unknown> {
    * @param {number} [priority=0] Optional priority, -1 is higher priority than 1
    * @return {Promise<any>} Resolved when the task has finished with the return value of fn
    */
-  run<U>(job: () => Promise<U>, priority?: number): Promise<U> {
+  run<U>(job: () => U | PromiseLike<U>, priority?: number): Promise<U> {
     const prio = priority ?? 0;
     const id = Symbol();
     return this.wait(id as T, prio)

test/ts.test.ts

@@ -29,4 +29,61 @@ describe('TS import', () => {
     const t: Promise<symbol> = q.run(() => Promise.resolve(Symbol()), 12);
     assert.instanceOf(t, Promise<symbol>);
   });
+
+  it('infers synchronous job results', async () => {
+    const q = new Queue();
+    const value = Symbol();
+    const result: Promise<symbol> = q.run(() => value);
+    assert.strictEqual(await result, value);
+    await q.flush();
+    assert.strictEqual(q.stat().running, 0);
+  });
+
+  it('accepts synchronous jobs without a return value', async () => {
+    const q = new Queue();
+    let ran = false;
+    const result: Promise<void> = q.run(() => {
+      ran = true;
+    });
+    assert.isUndefined(await result);
+    assert.isTrue(ran);
+    await q.flush();
+  });
+
+  it('infers jobs returning either values or promises', async () => {
+    const q = new Queue();
+    const job = (asynchronous: boolean): number | Promise<number> =>
+      asynchronous ? Promise.resolve(42) : 42;
+    const synchronous: Promise<number> = q.run(() => job(false));
+    const asynchronous: Promise<number> = q.run(() => job(true));
+    assert.strictEqual(await synchronous, 42);
+    assert.strictEqual(await asynchronous, 42);
+    await q.flush();
+  });
+
+  it('accepts promise like job results', async () => {
+    const q = new Queue();
+    const thenable: PromiseLike<number> = {
+      then: (onfulfilled, onrejected) => Promise.resolve(42).then(onfulfilled, onrejected)
+    };
+    const result: Promise<number> = q.run(() => thenable);
+    assert.strictEqual(await result, 42);
+    await q.flush();
+  });
+
+  it('releases capacity after a synchronous job throws', async () => {
+    const q = new Queue();
+    const error = new Error('job failed');
+    const failed: Promise<never> = q.run(() => {
+      throw error;
+    });
+    const next: Promise<string> = q.run(() => 'next');
+    await failed.then(
+      () => assert.fail('expected job rejection'),
+      (actual: Error) => assert.strictEqual(actual, error)
+    );
+    assert.strictEqual(await next, 'next');
+    await q.flush();
+    assert.strictEqual(q.stat().running, 0);
+  });
 });