Suspend incomplete requests

packages/core/core/src/RequestTracker.js

@@ -54,6 +54,7 @@ import {report} from './ReporterRunner';
 import {PromiseQueue} from '@parcel/utils';
 import type {Cache} from '@parcel/cache';
 import {getConfigKeyContentHash} from './requests/ConfigRequest';
+import {getFeatureFlag} from '@parcel/feature-flags';
 
 export const requestGraphEdgeTypes = {
   subrequest: 2,
@@ -132,6 +133,7 @@ type Request<TInput, TResult> = {|
   id: string,
   +type: RequestType,
   input: TInput,
+  incompleteRequest?: boolean,
   run: ({|input: TInput, ...StaticRunOpts<TResult>|}) => Async<TResult>,
 |};
 
@@ -1027,6 +1029,10 @@ export default class RequestTracker {
   farm: WorkerFarm;
   options: ParcelOptions;
   signal: ?AbortSignal;
+  incompleteRequests: Map<
+    Request<mixed, mixed>['id'],
+    {|deferred: Deferred<void>, promise: Promise<void>, timerId: TimeoutID|},
+  > = new Map();
 
   constructor({
     graph,
@@ -1160,11 +1166,63 @@ export default class RequestTracker {
     this.graph.replaceSubrequests(requestNodeId, subrequestContextKeys);
   }
 
+  flushCachedRequest(requestId: ContentKey) {
+    let existingPromise = this.incompleteRequests.get(requestId);
+
+    if (existingPromise) {
+      logger.verbose({
+        origin: '@parcel/core',
+        message: 'Incomplete request promise resolved',
+        meta: {trackableEvent: 'incomplete_promise_resolved'},
+      });
+
+      clearTimeout(existingPromise.timerId);
+      existingPromise.deferred.resolve();
+    }
+  }
+
+  waitForFullRequest(requestId: ContentKey): Promise<void> {
+    let existingPromise = this.incompleteRequests.get(requestId);
+
+    if (existingPromise) {
+      return existingPromise.promise;
+    }
+
+    let deferredPromise = makeDeferredWithPromise();
+
+    let timerId = setTimeout(() => {
+      logger.verbose({
+        origin: '@parcel/core',
+        message: 'Incomplete request promise timed out',
+        meta: {trackableEvent: 'incomplete_promise_timeout'},
+      });
+      deferredPromise.deferred.resolve();
+    }, 5_000);
+
+    this.incompleteRequests.set(requestId, {...deferredPromise, timerId});
+
+    return deferredPromise.promise;
+  }
+
   async runRequest<TInput, TResult>(
     request: Request<TInput, TResult>,
     opts?: ?RunRequestOpts,
   ): Promise<TResult> {
-    let requestId = this.graph.hasContentKey(request.id)
+    let hasKey = this.graph.hasContentKey(request.id);
+
+    if (
+      request.incompleteRequest &&
+      !hasKey &&
+      getFeatureFlag('devDepRequestBugFix')
+    ) {
+      // To avoid possible race conditions with the worker farm build cache, we
+      // suspend processing of an incomplete request until the full details are back
+      // from another worker.
+      await this.waitForFullRequest(request.id);
+      hasKey = this.graph.hasContentKey(request.id);
+    }
+
+    let requestId = hasKey
       ? this.graph.getNodeIdByContentKey(request.id)
       : undefined;
     let hasValidResult = requestId != null && this.hasValidResult(requestId);
@@ -1223,6 +1281,9 @@ export default class RequestTracker {
       deferred.resolve(false);
       throw err;
     } finally {
+      if (getFeatureFlag('devDepRequestBugFix')) {
+        this.flushCachedRequest(request.id);
+      }
       this.graph.replaceSubrequests(requestNodeId, [...subRequestContentKeys]);
     }
   }

packages/core/core/src/requests/DevDepRequest.js

@@ -190,14 +190,22 @@ export async function runDevDepRequest<TResult>(
   await api.runRequest<null, DevDepRequestResult | void>({
     id: 'dev_dep_request:' + devDepRequest.specifier + ':' + devDepRequest.hash,
     type: requestTypes.dev_dep_request,
+    incompleteRequest: !(
+      devDepRequest.invalidateOnFileChange &&
+      devDepRequest.invalidateOnFileCreate
+    ),
     run: ({api}) => {
-      for (let filePath of nullthrows(devDepRequest.invalidateOnFileChange)) {
+      for (let filePath of nullthrows(
+        devDepRequest.invalidateOnFileChange,
+        'DevDepRequest missing invalidateOnFileChange',
+      )) {
         api.invalidateOnFileUpdate(filePath);
         api.invalidateOnFileDelete(filePath);
       }
 
       for (let invalidation of nullthrows(
         devDepRequest.invalidateOnFileCreate,
+        'DevDepRequest missing invalidateOnFileCreate',
       )) {
         api.invalidateOnFileCreate(invalidation);
       }

packages/core/feature-flags/src/index.js

@@ -8,6 +8,7 @@ export type FeatureFlags = _FeatureFlags;
 export const DEFAULT_FEATURE_FLAGS: FeatureFlags = {
   exampleFeature: false,
   configKeyInvalidation: false,
+  devDepRequestBugFix: false,
 };
 
 let featureFlagValues: FeatureFlags = {...DEFAULT_FEATURE_FLAGS};

packages/core/feature-flags/src/types.js

@@ -9,4 +9,8 @@ export type FeatureFlags = {|
    * `config.getConfigFrom(..., {packageKey: '...'})` and the value itself hasn't changed.
    */
   +configKeyInvalidation: boolean,
+  /**
+   * Enable experimental fix for the DevDepRequest build cache bug
+   */
+  +devDepRequestBugFix: boolean,
 |};