Add firstRunPromise

docs/source/api/tracker.md

@@ -302,6 +302,26 @@ recomputed at flush time.
 This property is a convenience to support the common pattern where a
 computation has logic specific to the first run.
 
+{% apibox "Tracker.Computation#firstRunPromise" %}
+
+`Computation.firstRunPromise` will be set to the result of the call of the autorun function after the initial computation has been completed. If the autorun function is an async function, it'll then contain its promise, thus making the completion of the execution await-able. That allows us to manually synchronize autoruns like this:
+
+```js  
+
+await Tracker.autorun(async () => {
+  await Meteor.userAsync();
+  (...more async code...)
+}).firstRunPromise;
+
+await Tracker.autorun(async () => {
+  await asyncSomeOrOther();
+  (...more async code...)
+}).firstRunPromise;
+
+// ta-daa! We'll get here only after both the autorun functions will have returned & executed in their entirety.
+
+
+```
 <h2 id="tracker_dependency"><span>Tracker.Dependency</span></h2>
 
 A Dependency represents an atomic unit of reactive data that a

packages/tracker/tracker.d.ts

@@ -16,6 +16,10 @@ export namespace Tracker {
      * True during the initial run of the computation at the time `Tracker.autorun` is called, and false on subsequent reruns and at other times.
      */
     firstRun: boolean;
+    /**
+     * Forces autorun blocks to be executed in synchronous-looking order by storing the value autorun promise thus making it awaitable.
+     */
+    firstRunPromise: Promise<unknown>
     /**
      * Invalidates this computation so that it will be rerun.
      */

packages/tracker/tracker.js

@@ -196,6 +196,31 @@ Tracker.Computation = class Computation {
     this._onError = onError;
     this._recomputing = false;
 
+    /**
+     * @summary Forces autorun blocks to be executed in synchronous-looking order by storing the value autorun promise thus making it awaitable.
+     * @locus Client
+     * @memberOf Tracker.Computation
+     * @instance
+     * @name  firstRunPromise
+     * @returns {Promise<unknown>}
+     */
+    this.firstRunPromise = undefined;
+
+    /**
+   * 
+   * @param {*} onResolved 
+   * @param {*} onRejected 
+   * @returns 
+   */
+  this.then = async function (onResolved, onRejected) {
+    await this.firstRunPromise.then(onResolved, onRejected);
+  };
+
+
+  this.catch = async function (onRejected) {
+    await this.firstRunPromise.catch(onRejected)
+  };
+
     var errored = true;
     try {
       this._compute();
@@ -297,10 +322,18 @@ Tracker.Computation = class Computation {
 
     var previousInCompute = inCompute;
     inCompute = true;
+
     try {
-      Tracker.withComputation(this, () => {
+      // In case of async functions, the result of this function will contain the promise of the autorun function
+      // & make autoruns await-able.
+      const firstRunPromise = Tracker.withComputation(this, () => {
         withNoYieldsAllowed(this._func)(this);
-      });
+      })
+      // We'll store the firstRunPromise on the computation so it can be awaited by the callers, but only
+      // during the first run. We don't want things to get mixed up.
+      if (this.firstRun) {
+        this.firstRunPromise = firstRunPromise;
+      }
     } finally {
       inCompute = previousInCompute;
     }
@@ -560,21 +593,18 @@ Tracker._runFlush = function (options) {
  * thrown. Defaults to the error being logged to the console.
  * @returns {Tracker.Computation}
  */
-Tracker.autorun = function (f, options) {
+Tracker.autorun = function (f, options = {}) {
   if (typeof f !== 'function')
     throw new Error('Tracker.autorun requires a function argument');
 
-  options = options || {};
-
   constructingComputation = true;
-  var c = new Tracker.Computation(
-    f, Tracker.currentComputation, options.onError);
+  var c = new Tracker.Computation(f, Tracker.currentComputation, options.onError);
 
   if (Tracker.active)
     Tracker.onInvalidate(function () {
       c.stop();
     });
-
+    
   return c;
 };
 

packages/tracker/tracker_tests.js

@@ -297,7 +297,7 @@ Tinytest.add("tracker - lifecycle", function (test) {
     test.equal(c, Tracker.currentComputation);
     test.equal(c.stopped, false);
     test.equal(c.invalidated, false);
-      test.equal(c.firstRun, firstRun);
+    test.equal(c.firstRun, firstRun);
 
     Tracker.onInvalidate(makeCb()); // 1, 6, ...
     Tracker.afterFlush(makeCb()); // 2, 7, ...
@@ -630,6 +630,54 @@ Tinytest.addAsync('tracker - async function - stepped', async function (test) {
   test.equal(count, limit, 'after resolve');
 });
 
+
+Tinytest.addAsync('tracker - async function - synchronize', async test => {
+  let counter = 0;
+
+  await Tracker.autorun(async () => {
+    test.equal(counter, 0);
+    counter += 1;
+    test.equal(counter, 1);
+    await Promise.resolve();
+    test.equal(counter, 1);
+    counter *= 2;
+    test.equal(counter, 2);
+  });
+
+  await Tracker.autorun(async () => {
+    test.equal(counter, 2);
+    counter += 1;
+    test.equal(counter, 3);
+    await Promise.resolve();
+    test.equal(counter, 3);
+    counter *= 2;
+    test.equal(counter, 6);
+  });
+})
+
+Tinytest.addAsync('tracker - async function - synchronize - firstRunPromise', async test => {
+  let counter = 0
+  await Tracker.autorun(async () => {
+    test.equal(counter, 0);
+    counter += 1;
+    test.equal(counter, 1);
+    await Promise.resolve();
+    test.equal(counter, 1);
+    counter *= 2;
+    test.equal(counter, 2);
+  }).firstRunPromise;
+
+  await Tracker.autorun(async () => {
+    test.equal(counter, 2);
+    counter += 1;
+    test.equal(counter, 3);
+    await Promise.resolve();
+    test.equal(counter, 3);
+    counter *= 2;
+    test.equal(counter, 6);
+  }).firstRunPromise;
+})
+
 Tinytest.add('computation - #flush', function (test) {
   var i = 0, j = 0, d = new Tracker.Dependency;
   var c1 = Tracker.autorun(function () {